From 094517bd6cbbe7028f257fc83b04aa8e48ae8060 Mon Sep 17 00:00:00 2001 From: lhw <1191862386@qq.com> Date: Sun, 24 Mar 2024 07:07:48 -0400 Subject: [PATCH] test1 --- Cargo.lock | 90 +- Cargo.toml | 2 + cranelift/codegen/meta/src/isa/x86.rs | 15 +- .../codegen/meta/src/shared/instructions.rs | 24 + cranelift/codegen/src/ir/entities.rs | 5 + .../codegen/src/isa/aarch64/lower_inst.rs | 4 + cranelift/codegen/src/isa/s390x/lower.rs | 4 + cranelift/codegen/src/isa/x64/inst.isle | 26 + cranelift/codegen/src/isa/x64/inst/args.rs | 31 + cranelift/codegen/src/isa/x64/inst/emit.rs | 46 + cranelift/codegen/src/isa/x64/inst/mod.rs | 30 + cranelift/codegen/src/isa/x64/lower.isle | 9 + cranelift/codegen/src/isa/x64/lower.rs | 4 +- cranelift/codegen/src/isa/x64/lower/isle.rs | 5 + cranelift/codegen/src/machinst/buffer.rs | 2 +- cranelift/interpreter/src/step.rs | 3 + cranelift/native/src/lib.rs | 7 +- cranelift/wasm/Cargo.toml | 2 +- cranelift/wasm/src/code_translator.rs | 9 + cranelift/wasm/src/environ/spec.rs | 18 +- crates/cranelift/Cargo.toml | 2 +- crates/cranelift/src/func_environ.rs | 1 + crates/environ/Cargo.toml | 2 +- crates/environ/src/module.rs | 1 + crates/environ/src/module_environ.rs | 60 +- crates/jit/src/code_memory.rs | 2 +- crates/runtime/src/cow.rs | 16 + crates/runtime/src/externref.rs | 2 +- crates/runtime/src/instance/allocator.rs | 9 +- .../runtime/src/instance/allocator/pooling.rs | 5 +- crates/runtime/src/lib.rs | 2 + crates/runtime/src/pku.rs | 90 + crates/runtime/src/traphandlers.rs | 6 +- crates/runtime/src/traphandlers/unix.rs | 3 +- crates/types/Cargo.toml | 2 +- crates/wasi-common/Cargo.toml | 1 + crates/wasi-common/cap-std-sync/src/file.rs | 59 + crates/wasi-common/cap-std-sync/src/stdio.rs | 8 + crates/wasi-common/src/file.rs | 56 +- crates/wasi-common/src/pipe.rs | 1 + crates/wasi-common/src/snapshots/preview_0.rs | 64 +- crates/wasi-common/src/snapshots/preview_1.rs | 1280 ++++++- crates/wasi/src/lib.rs | 3 +- crates/wasmparser/Cargo.lock | 629 +++ crates/wasmparser/Cargo.toml | 57 + crates/wasmparser/Cargo.toml.orig | 35 + crates/wasmparser/LICENSE | 220 ++ crates/wasmparser/README.md | 36 + crates/wasmparser/benches/.gitignore | 1 + crates/wasmparser/benches/benchmark.rs | 914 +++++ crates/wasmparser/benches/bz2.wasm | Bin 0 -> 187897 bytes crates/wasmparser/benches/intgemm-simd.wasm | Bin 0 -> 167965 bytes crates/wasmparser/benches/pulldown-cmark.wasm | Bin 0 -> 1983577 bytes crates/wasmparser/benches/spidermonkey.wasm | Bin 0 -> 5399306 bytes crates/wasmparser/examples/simple.rs | 37 + crates/wasmparser/src/binary_reader.rs | 2847 ++++++++++++++ crates/wasmparser/src/lib.rs | 39 + crates/wasmparser/src/limits.rs | 57 + crates/wasmparser/src/parser.rs | 1434 +++++++ crates/wasmparser/src/readers.rs | 152 + crates/wasmparser/src/readers/component.rs | 15 + .../src/readers/component/aliases.rs | 225 ++ .../src/readers/component/canonicals.rs | 124 + .../src/readers/component/exports.rs | 108 + .../src/readers/component/imports.rs | 125 + .../src/readers/component/instances.rs | 240 ++ .../wasmparser/src/readers/component/start.rs | 64 + .../wasmparser/src/readers/component/types.rs | 437 +++ crates/wasmparser/src/readers/core.rs | 37 + crates/wasmparser/src/readers/core/code.rs | 270 ++ crates/wasmparser/src/readers/core/custom.rs | 63 + crates/wasmparser/src/readers/core/data.rs | 189 + .../wasmparser/src/readers/core/elements.rs | 333 ++ crates/wasmparser/src/readers/core/exports.rs | 123 + .../wasmparser/src/readers/core/functions.rs | 95 + crates/wasmparser/src/readers/core/globals.rs | 110 + crates/wasmparser/src/readers/core/imports.rs | 129 + crates/wasmparser/src/readers/core/init.rs | 46 + crates/wasmparser/src/readers/core/linking.rs | 88 + .../wasmparser/src/readers/core/memories.rs | 93 + crates/wasmparser/src/readers/core/names.rs | 355 ++ .../wasmparser/src/readers/core/operators.rs | 2496 ++++++++++++ .../wasmparser/src/readers/core/producers.rs | 211 + crates/wasmparser/src/readers/core/relocs.rs | 198 + crates/wasmparser/src/readers/core/tables.rs | 93 + crates/wasmparser/src/readers/core/tags.rs | 92 + crates/wasmparser/src/readers/core/types.rs | 230 ++ crates/wasmparser/src/resources.rs | 327 ++ crates/wasmparser/src/validator.rs | 1455 +++++++ crates/wasmparser/src/validator/component.rs | 2087 ++++++++++ crates/wasmparser/src/validator/core.rs | 1016 +++++ crates/wasmparser/src/validator/func.rs | 760 ++++ crates/wasmparser/src/validator/operators.rs | 3396 +++++++++++++++++ crates/wasmparser/src/validator/types.rs | 1901 +++++++++ crates/wasmtime/Cargo.toml | 4 +- crates/wasmtime/src/engine.rs | 1 + crates/wasmtime/src/func.rs | 24 +- crates/wasmtime/src/func/typed.rs | 2 +- crates/wasmtime/src/instance.rs | 1 + crates/wasmtime/src/isolated_memory.rs | 75 + crates/wasmtime/src/lib.rs | 2 + crates/wasmtime/src/linker.rs | 6 +- crates/wasmtime/src/store.rs | 9 +- crates/wastlhw/.cargo-ok | 1 + crates/wastlhw/.cargo_vcs_info.json | 6 + crates/wastlhw/Cargo.toml | 51 + crates/wastlhw/Cargo.toml.orig | 40 + crates/wastlhw/LICENSE | 220 ++ crates/wastlhw/README.md | 62 + crates/wastlhw/src/component.rs | 28 + crates/wastlhw/src/component/alias.rs | 324 ++ crates/wastlhw/src/component/binary.rs | 842 ++++ crates/wastlhw/src/component/component.rs | 318 ++ crates/wastlhw/src/component/custom.rs | 28 + crates/wastlhw/src/component/expand.rs | 825 ++++ crates/wastlhw/src/component/export.rs | 141 + crates/wastlhw/src/component/func.rs | 373 ++ crates/wastlhw/src/component/import.rs | 150 + crates/wastlhw/src/component/instance.rs | 296 ++ crates/wastlhw/src/component/item_ref.rs | 154 + crates/wastlhw/src/component/module.rs | 75 + crates/wastlhw/src/component/resolve.rs | 1010 +++++ crates/wastlhw/src/component/types.rs | 953 +++++ crates/wastlhw/src/component/wast.rs | 163 + crates/wastlhw/src/core.rs | 29 + crates/wastlhw/src/core/binary.rs | 1081 ++++++ crates/wastlhw/src/core/custom.rs | 151 + crates/wastlhw/src/core/export.rs | 146 + crates/wastlhw/src/core/expr.rs | 1886 +++++++++ crates/wastlhw/src/core/func.rs | 121 + crates/wastlhw/src/core/global.rs | 59 + crates/wastlhw/src/core/import.rs | 158 + crates/wastlhw/src/core/memory.rs | 279 ++ crates/wastlhw/src/core/module.rs | 210 + .../core/resolve/deinline_import_export.rs | 228 ++ crates/wastlhw/src/core/resolve/mod.rs | 109 + crates/wastlhw/src/core/resolve/names.rs | 746 ++++ crates/wastlhw/src/core/resolve/types.rs | 261 ++ crates/wastlhw/src/core/table.rs | 229 ++ crates/wastlhw/src/core/tag.rs | 71 + crates/wastlhw/src/core/types.rs | 779 ++++ crates/wastlhw/src/core/wast.rs | 226 ++ crates/wastlhw/src/encode.rs | 75 + crates/wastlhw/src/error.rs | 196 + crates/wastlhw/src/gensym.rs | 20 + crates/wastlhw/src/lexer.rs | 1267 ++++++ crates/wastlhw/src/lib.rs | 513 +++ crates/wastlhw/src/names.rs | 86 + crates/wastlhw/src/parser.rs | 1313 +++++++ crates/wastlhw/src/token.rs | 697 ++++ crates/wastlhw/src/wast.rs | 365 ++ crates/wastlhw/src/wat.rs | 60 + crates/wastlhw/tests/.gitattributes | 1 + crates/wastlhw/tests/.gitignore | 1 + crates/wastlhw/tests/annotations.rs | 197 + crates/wastlhw/tests/comments.rs | 76 + crates/wastlhw/tests/parse-fail.rs | 98 + crates/wastlhw/tests/parse-fail/bad-index.wat | 1 + .../tests/parse-fail/bad-index.wat.err | 5 + crates/wastlhw/tests/parse-fail/bad-name.wat | 1 + .../wastlhw/tests/parse-fail/bad-name.wat.err | 5 + crates/wastlhw/tests/parse-fail/bad-name2.wat | 2 + .../tests/parse-fail/bad-name2.wat.err | 5 + crates/wastlhw/tests/parse-fail/bad-name3.wat | 1 + .../tests/parse-fail/bad-name3.wat.err | 5 + crates/wastlhw/tests/parse-fail/block1.wat | 1 + .../wastlhw/tests/parse-fail/block1.wat.err | 5 + crates/wastlhw/tests/parse-fail/block2.wat | 1 + .../wastlhw/tests/parse-fail/block2.wat.err | 5 + crates/wastlhw/tests/parse-fail/block3.wat | 1 + .../wastlhw/tests/parse-fail/block3.wat.err | 5 + .../parse-fail/confusing-block-comment0.wat | 1 + .../confusing-block-comment0.wat.err | 5 + .../parse-fail/confusing-block-comment1.wat | 1 + .../confusing-block-comment1.wat.err | 5 + .../parse-fail/confusing-block-comment2.wat | 1 + .../confusing-block-comment2.wat.err | 5 + .../parse-fail/confusing-block-comment3.wat | 1 + .../confusing-block-comment3.wat.err | 5 + .../parse-fail/confusing-block-comment4.wat | 1 + .../confusing-block-comment4.wat.err | 5 + .../parse-fail/confusing-block-comment5.wat | 1 + .../confusing-block-comment5.wat.err | 5 + .../parse-fail/confusing-block-comment6.wat | 1 + .../confusing-block-comment6.wat.err | 5 + .../parse-fail/confusing-block-comment7.wat | 1 + .../confusing-block-comment7.wat.err | 5 + .../parse-fail/confusing-block-comment8.wat | 1 + .../confusing-block-comment8.wat.err | 5 + .../parse-fail/confusing-line-comment0.wat | 1 + .../confusing-line-comment0.wat.err | 5 + .../parse-fail/confusing-line-comment1.wat | 1 + .../confusing-line-comment1.wat.err | 5 + .../parse-fail/confusing-line-comment2.wat | 1 + .../confusing-line-comment2.wat.err | 5 + .../parse-fail/confusing-line-comment3.wat | 1 + .../confusing-line-comment3.wat.err | 5 + .../parse-fail/confusing-line-comment4.wat | 1 + .../confusing-line-comment4.wat.err | 5 + .../parse-fail/confusing-line-comment5.wat | 1 + .../confusing-line-comment5.wat.err | 5 + .../parse-fail/confusing-line-comment6.wat | 1 + .../confusing-line-comment6.wat.err | 5 + .../parse-fail/confusing-line-comment7.wat | 1 + .../confusing-line-comment7.wat.err | 5 + .../parse-fail/confusing-line-comment8.wat | 1 + .../confusing-line-comment8.wat.err | 5 + .../tests/parse-fail/confusing-string0.wat | 1 + .../parse-fail/confusing-string0.wat.err | 5 + .../tests/parse-fail/confusing-string1.wat | 1 + .../parse-fail/confusing-string1.wat.err | 5 + .../tests/parse-fail/confusing-string2.wat | 1 + .../parse-fail/confusing-string2.wat.err | 5 + .../tests/parse-fail/confusing-string3.wat | 1 + .../parse-fail/confusing-string3.wat.err | 5 + .../tests/parse-fail/confusing-string4.wat | 1 + .../parse-fail/confusing-string4.wat.err | 5 + .../tests/parse-fail/confusing-string5.wat | 1 + .../parse-fail/confusing-string5.wat.err | 5 + .../tests/parse-fail/confusing-string6.wat | 1 + .../parse-fail/confusing-string6.wat.err | 5 + .../tests/parse-fail/confusing-string7.wat | 1 + .../parse-fail/confusing-string7.wat.err | 5 + .../tests/parse-fail/confusing-string8.wat | 1 + .../parse-fail/confusing-string8.wat.err | 5 + crates/wastlhw/tests/parse-fail/inline1.wat | 4 + .../wastlhw/tests/parse-fail/inline1.wat.err | 5 + .../tests/parse-fail/newline-in-string.wat | 1 + .../parse-fail/newline-in-string.wat.err | 5 + crates/wastlhw/tests/parse-fail/string1.wat | 2 + .../wastlhw/tests/parse-fail/string1.wat.err | 5 + crates/wastlhw/tests/parse-fail/string10.wat | 1 + .../wastlhw/tests/parse-fail/string10.wat.err | 5 + crates/wastlhw/tests/parse-fail/string11.wat | 1 + .../wastlhw/tests/parse-fail/string11.wat.err | 5 + crates/wastlhw/tests/parse-fail/string12.wat | 1 + .../wastlhw/tests/parse-fail/string12.wat.err | 5 + crates/wastlhw/tests/parse-fail/string13.wat | 1 + .../wastlhw/tests/parse-fail/string13.wat.err | 5 + crates/wastlhw/tests/parse-fail/string14.wat | 1 + .../wastlhw/tests/parse-fail/string14.wat.err | 5 + crates/wastlhw/tests/parse-fail/string15.wat | 1 + .../wastlhw/tests/parse-fail/string15.wat.err | 5 + crates/wastlhw/tests/parse-fail/string16.wat | 1 + .../wastlhw/tests/parse-fail/string16.wat.err | 5 + crates/wastlhw/tests/parse-fail/string2.wat | 2 + .../wastlhw/tests/parse-fail/string2.wat.err | 5 + crates/wastlhw/tests/parse-fail/string3.wat | 3 + .../wastlhw/tests/parse-fail/string3.wat.err | 5 + crates/wastlhw/tests/parse-fail/string4.wat | 2 + .../wastlhw/tests/parse-fail/string4.wat.err | 5 + crates/wastlhw/tests/parse-fail/string5.wat | 1 + .../wastlhw/tests/parse-fail/string5.wat.err | 5 + crates/wastlhw/tests/parse-fail/string6.wat | Bin 0 -> 4 bytes .../wastlhw/tests/parse-fail/string6.wat.err | Bin 0 -> 109 bytes crates/wastlhw/tests/parse-fail/string7.wat | 1 + .../wastlhw/tests/parse-fail/string7.wat.err | 5 + crates/wastlhw/tests/parse-fail/string8.wat | 1 + .../wastlhw/tests/parse-fail/string8.wat.err | 5 + crates/wastlhw/tests/parse-fail/string9.wat | 1 + .../wastlhw/tests/parse-fail/string9.wat.err | 5 + .../wastlhw/tests/parse-fail/unbalanced.wat | 3 + .../tests/parse-fail/unbalanced.wat.err | 5 + crates/wastlhw/tests/recursive.rs | 8 + crates/wat/.cargo-ok | 1 + crates/wat/.cargo_vcs_info.json | 6 + crates/wat/Cargo.toml | 29 + crates/wat/Cargo.toml.orig | 16 + crates/wat/LICENSE | 220 ++ crates/wat/README.md | 74 + crates/wat/src/lib.rs | 333 ++ crates/wiggle/Cargo.toml | 1 + crates/wiggle/src/lib.rs | 88 + src/bin/wasmtime.rs | 5 + src/commands.rs | 4 +- src/commands/pku.rs | 664 ++++ src/commands/raiden/ei.rs | 25 + src/commands/raiden/mod.rs | 14 + src/commands/run.rs | 12 +- 279 files changed, 45578 insertions(+), 163 deletions(-) create mode 100644 crates/runtime/src/pku.rs create mode 100644 crates/wasmparser/Cargo.lock create mode 100644 crates/wasmparser/Cargo.toml create mode 100644 crates/wasmparser/Cargo.toml.orig create mode 100644 crates/wasmparser/LICENSE create mode 100644 crates/wasmparser/README.md create mode 100644 crates/wasmparser/benches/.gitignore create mode 100644 crates/wasmparser/benches/benchmark.rs create mode 100644 crates/wasmparser/benches/bz2.wasm create mode 100644 crates/wasmparser/benches/intgemm-simd.wasm create mode 100644 crates/wasmparser/benches/pulldown-cmark.wasm create mode 100644 crates/wasmparser/benches/spidermonkey.wasm create mode 100644 crates/wasmparser/examples/simple.rs create mode 100644 crates/wasmparser/src/binary_reader.rs create mode 100644 crates/wasmparser/src/lib.rs create mode 100644 crates/wasmparser/src/limits.rs create mode 100644 crates/wasmparser/src/parser.rs create mode 100644 crates/wasmparser/src/readers.rs create mode 100644 crates/wasmparser/src/readers/component.rs create mode 100644 crates/wasmparser/src/readers/component/aliases.rs create mode 100644 crates/wasmparser/src/readers/component/canonicals.rs create mode 100644 crates/wasmparser/src/readers/component/exports.rs create mode 100644 crates/wasmparser/src/readers/component/imports.rs create mode 100644 crates/wasmparser/src/readers/component/instances.rs create mode 100644 crates/wasmparser/src/readers/component/start.rs create mode 100644 crates/wasmparser/src/readers/component/types.rs create mode 100644 crates/wasmparser/src/readers/core.rs create mode 100644 crates/wasmparser/src/readers/core/code.rs create mode 100644 crates/wasmparser/src/readers/core/custom.rs create mode 100644 crates/wasmparser/src/readers/core/data.rs create mode 100644 crates/wasmparser/src/readers/core/elements.rs create mode 100644 crates/wasmparser/src/readers/core/exports.rs create mode 100644 crates/wasmparser/src/readers/core/functions.rs create mode 100644 crates/wasmparser/src/readers/core/globals.rs create mode 100644 crates/wasmparser/src/readers/core/imports.rs create mode 100644 crates/wasmparser/src/readers/core/init.rs create mode 100644 crates/wasmparser/src/readers/core/linking.rs create mode 100644 crates/wasmparser/src/readers/core/memories.rs create mode 100644 crates/wasmparser/src/readers/core/names.rs create mode 100644 crates/wasmparser/src/readers/core/operators.rs create mode 100644 crates/wasmparser/src/readers/core/producers.rs create mode 100644 crates/wasmparser/src/readers/core/relocs.rs create mode 100644 crates/wasmparser/src/readers/core/tables.rs create mode 100644 crates/wasmparser/src/readers/core/tags.rs create mode 100644 crates/wasmparser/src/readers/core/types.rs create mode 100644 crates/wasmparser/src/resources.rs create mode 100644 crates/wasmparser/src/validator.rs create mode 100644 crates/wasmparser/src/validator/component.rs create mode 100644 crates/wasmparser/src/validator/core.rs create mode 100644 crates/wasmparser/src/validator/func.rs create mode 100644 crates/wasmparser/src/validator/operators.rs create mode 100644 crates/wasmparser/src/validator/types.rs create mode 100644 crates/wasmtime/src/isolated_memory.rs create mode 100644 crates/wastlhw/.cargo-ok create mode 100644 crates/wastlhw/.cargo_vcs_info.json create mode 100644 crates/wastlhw/Cargo.toml create mode 100644 crates/wastlhw/Cargo.toml.orig create mode 100644 crates/wastlhw/LICENSE create mode 100644 crates/wastlhw/README.md create mode 100644 crates/wastlhw/src/component.rs create mode 100644 crates/wastlhw/src/component/alias.rs create mode 100644 crates/wastlhw/src/component/binary.rs create mode 100644 crates/wastlhw/src/component/component.rs create mode 100644 crates/wastlhw/src/component/custom.rs create mode 100644 crates/wastlhw/src/component/expand.rs create mode 100644 crates/wastlhw/src/component/export.rs create mode 100644 crates/wastlhw/src/component/func.rs create mode 100644 crates/wastlhw/src/component/import.rs create mode 100644 crates/wastlhw/src/component/instance.rs create mode 100644 crates/wastlhw/src/component/item_ref.rs create mode 100644 crates/wastlhw/src/component/module.rs create mode 100644 crates/wastlhw/src/component/resolve.rs create mode 100644 crates/wastlhw/src/component/types.rs create mode 100644 crates/wastlhw/src/component/wast.rs create mode 100644 crates/wastlhw/src/core.rs create mode 100644 crates/wastlhw/src/core/binary.rs create mode 100644 crates/wastlhw/src/core/custom.rs create mode 100644 crates/wastlhw/src/core/export.rs create mode 100644 crates/wastlhw/src/core/expr.rs create mode 100644 crates/wastlhw/src/core/func.rs create mode 100644 crates/wastlhw/src/core/global.rs create mode 100644 crates/wastlhw/src/core/import.rs create mode 100644 crates/wastlhw/src/core/memory.rs create mode 100644 crates/wastlhw/src/core/module.rs create mode 100644 crates/wastlhw/src/core/resolve/deinline_import_export.rs create mode 100644 crates/wastlhw/src/core/resolve/mod.rs create mode 100644 crates/wastlhw/src/core/resolve/names.rs create mode 100644 crates/wastlhw/src/core/resolve/types.rs create mode 100644 crates/wastlhw/src/core/table.rs create mode 100644 crates/wastlhw/src/core/tag.rs create mode 100644 crates/wastlhw/src/core/types.rs create mode 100644 crates/wastlhw/src/core/wast.rs create mode 100644 crates/wastlhw/src/encode.rs create mode 100644 crates/wastlhw/src/error.rs create mode 100644 crates/wastlhw/src/gensym.rs create mode 100644 crates/wastlhw/src/lexer.rs create mode 100644 crates/wastlhw/src/lib.rs create mode 100644 crates/wastlhw/src/names.rs create mode 100644 crates/wastlhw/src/parser.rs create mode 100644 crates/wastlhw/src/token.rs create mode 100644 crates/wastlhw/src/wast.rs create mode 100644 crates/wastlhw/src/wat.rs create mode 100644 crates/wastlhw/tests/.gitattributes create mode 100644 crates/wastlhw/tests/.gitignore create mode 100644 crates/wastlhw/tests/annotations.rs create mode 100644 crates/wastlhw/tests/comments.rs create mode 100644 crates/wastlhw/tests/parse-fail.rs create mode 100644 crates/wastlhw/tests/parse-fail/bad-index.wat create mode 100644 crates/wastlhw/tests/parse-fail/bad-index.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/bad-name.wat create mode 100644 crates/wastlhw/tests/parse-fail/bad-name.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/bad-name2.wat create mode 100644 crates/wastlhw/tests/parse-fail/bad-name2.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/bad-name3.wat create mode 100644 crates/wastlhw/tests/parse-fail/bad-name3.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/block1.wat create mode 100644 crates/wastlhw/tests/parse-fail/block1.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/block2.wat create mode 100644 crates/wastlhw/tests/parse-fail/block2.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/block3.wat create mode 100644 crates/wastlhw/tests/parse-fail/block3.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment0.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment0.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment1.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment1.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment2.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment2.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment3.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment3.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment4.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment4.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment5.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment5.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment6.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment6.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment7.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment7.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment8.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-block-comment8.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment0.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment0.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment1.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment1.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment2.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment2.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment3.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment3.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment4.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment4.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment5.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment5.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment6.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment6.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment7.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment7.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment8.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-line-comment8.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string0.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string0.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string1.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string1.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string2.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string2.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string3.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string3.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string4.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string4.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string5.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string5.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string6.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string6.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string7.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string7.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string8.wat create mode 100644 crates/wastlhw/tests/parse-fail/confusing-string8.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/inline1.wat create mode 100644 crates/wastlhw/tests/parse-fail/inline1.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/newline-in-string.wat create mode 100644 crates/wastlhw/tests/parse-fail/newline-in-string.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string1.wat create mode 100644 crates/wastlhw/tests/parse-fail/string1.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string10.wat create mode 100644 crates/wastlhw/tests/parse-fail/string10.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string11.wat create mode 100644 crates/wastlhw/tests/parse-fail/string11.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string12.wat create mode 100644 crates/wastlhw/tests/parse-fail/string12.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string13.wat create mode 100644 crates/wastlhw/tests/parse-fail/string13.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string14.wat create mode 100644 crates/wastlhw/tests/parse-fail/string14.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string15.wat create mode 100644 crates/wastlhw/tests/parse-fail/string15.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string16.wat create mode 100644 crates/wastlhw/tests/parse-fail/string16.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string2.wat create mode 100644 crates/wastlhw/tests/parse-fail/string2.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string3.wat create mode 100644 crates/wastlhw/tests/parse-fail/string3.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string4.wat create mode 100644 crates/wastlhw/tests/parse-fail/string4.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string5.wat create mode 100644 crates/wastlhw/tests/parse-fail/string5.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string6.wat create mode 100644 crates/wastlhw/tests/parse-fail/string6.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string7.wat create mode 100644 crates/wastlhw/tests/parse-fail/string7.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string8.wat create mode 100644 crates/wastlhw/tests/parse-fail/string8.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/string9.wat create mode 100644 crates/wastlhw/tests/parse-fail/string9.wat.err create mode 100644 crates/wastlhw/tests/parse-fail/unbalanced.wat create mode 100644 crates/wastlhw/tests/parse-fail/unbalanced.wat.err create mode 100644 crates/wastlhw/tests/recursive.rs create mode 100644 crates/wat/.cargo-ok create mode 100644 crates/wat/.cargo_vcs_info.json create mode 100644 crates/wat/Cargo.toml create mode 100644 crates/wat/Cargo.toml.orig create mode 100644 crates/wat/LICENSE create mode 100644 crates/wat/README.md create mode 100644 crates/wat/src/lib.rs create mode 100644 src/commands/pku.rs create mode 100644 src/commands/raiden/ei.rs create mode 100644 src/commands/raiden/mod.rs diff --git a/Cargo.lock b/Cargo.lock index 6fb857c6c..93a5321fc 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -738,7 +738,7 @@ dependencies = [ "termcolor", "thiserror", "walkdir", - "wat", + "wat 1.0.48 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -754,9 +754,9 @@ dependencies = [ "serde", "smallvec", "target-lexicon", - "wasmparser", + "wasmparser 0.89.1", "wasmtime-types", - "wat", + "wat 1.0.48 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -1259,6 +1259,15 @@ dependencies = [ "version_check", ] +[[package]] +name = "getopts" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5" +dependencies = [ + "unicode-width", +] + [[package]] name = "getrandom" version = "0.1.16" @@ -1908,9 +1917,9 @@ dependencies = [ [[package]] name = "once_cell" -version = "1.12.0" +version = "1.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7709cef83f0c1f58f666e746a08b21e0085f7440fa6a29cc194d68aac97a4225" +checksum = "e82dad04139b71a90c080c8463fe0dc7902db5192d939bd0950f074d014339e1" [[package]] name = "oorandom" @@ -2841,7 +2850,7 @@ dependencies = [ "wasi-common", "wasmtime", "wasmtime-wasi", - "wat", + "wat 1.0.48 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -3127,6 +3136,7 @@ dependencies = [ "cap-rand", "cap-std", "io-extras", + "libc", "rustix", "thiserror", "tracing", @@ -3254,7 +3264,7 @@ dependencies = [ "rand 0.8.5", "thiserror", "wasm-encoder", - "wasmparser", + "wasmparser 0.89.1 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -3268,7 +3278,7 @@ dependencies = [ "indexmap", "leb128", "wasm-encoder", - "wasmparser", + "wasmparser 0.89.1 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -3277,7 +3287,7 @@ version = "0.1.0" dependencies = [ "ocaml-interop", "once_cell", - "wat", + "wat 1.0.48 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -3304,6 +3314,19 @@ dependencies = [ "parity-wasm", ] +[[package]] +name = "wasmparser" +version = "0.89.1" +dependencies = [ + "anyhow", + "criterion", + "getopts", + "indexmap", + "once_cell", + "rayon", + "wat 1.0.48", +] + [[package]] name = "wasmparser" version = "0.89.1" @@ -3320,7 +3343,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "aa9e5ee2f56cc8a5da489558114e8c118e5a8416d96aefe63dcf1b5b05b858c6" dependencies = [ "anyhow", - "wasmparser", + "wasmparser 0.89.1 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -3344,7 +3367,7 @@ dependencies = [ "target-lexicon", "tempfile", "wasi-cap-std-sync", - "wasmparser", + "wasmparser 0.89.1", "wasmtime-cache", "wasmtime-component-macro", "wasmtime-component-util", @@ -3354,7 +3377,7 @@ dependencies = [ "wasmtime-jit", "wasmtime-runtime", "wasmtime-wasi", - "wat", + "wat 1.0.48", "windows-sys", ] @@ -3379,7 +3402,7 @@ dependencies = [ "wasmtime-wasi", "wasmtime-wasi-crypto", "wasmtime-wasi-nn", - "wat", + "wat 1.0.48 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -3394,7 +3417,7 @@ dependencies = [ "wasmtime", "wasmtime-c-api-macros", "wasmtime-wasi", - "wat", + "wat 1.0.48 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -3433,6 +3456,7 @@ version = "2.0.0" dependencies = [ "anyhow", "async-trait", + "bitflags", "clap 3.2.8", "component-macro-test", "component-test-util", @@ -3464,7 +3488,7 @@ dependencies = [ "wasmtime-wasi-nn", "wasmtime-wast", "wast 46.0.0", - "wat", + "wat 1.0.48 (registry+https://github.com/rust-lang/crates.io-index)", "windows-sys", ] @@ -3509,7 +3533,7 @@ dependencies = [ "object", "target-lexicon", "thiserror", - "wasmparser", + "wasmparser 0.89.1", "wasmtime-environ", ] @@ -3530,11 +3554,11 @@ dependencies = [ "target-lexicon", "thiserror", "wasm-encoder", - "wasmparser", + "wasmparser 0.89.1", "wasmprinter", "wasmtime-component-util", "wasmtime-types", - "wat", + "wat 1.0.48 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -3545,10 +3569,10 @@ dependencies = [ "component-fuzz-util", "env_logger 0.9.0", "libfuzzer-sys", - "wasmparser", + "wasmparser 0.89.1 (registry+https://github.com/rust-lang/crates.io-index)", "wasmprinter", "wasmtime-environ", - "wat", + "wat 1.0.48 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -3607,11 +3631,11 @@ dependencies = [ "wasm-smith", "wasm-spec-interpreter", "wasmi", - "wasmparser", + "wasmparser 0.89.1 (registry+https://github.com/rust-lang/crates.io-index)", "wasmprinter", "wasmtime", "wasmtime-wast", - "wat", + "wat 1.0.48 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -3679,7 +3703,7 @@ dependencies = [ "cranelift-entity", "serde", "thiserror", - "wasmparser", + "wasmparser 0.89.1", ] [[package]] @@ -3746,6 +3770,25 @@ dependencies = [ "wasm-encoder", ] +[[package]] +name = "wastlhw" +version = "46.0.0" +dependencies = [ + "anyhow", + "leb128", + "memchr", + "rayon", + "unicode-width", + "wasm-encoder", +] + +[[package]] +name = "wat" +version = "1.0.48" +dependencies = [ + "wastlhw", +] + [[package]] name = "wat" version = "1.0.48" @@ -3783,6 +3826,7 @@ dependencies = [ "anyhow", "async-trait", "bitflags", + "libc", "proptest", "thiserror", "tokio", diff --git a/Cargo.toml b/Cargo.toml index 29d6936ff..d9d9872c0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -30,6 +30,7 @@ wasmtime-wast = { path = "crates/wast", version = "=2.0.0" } wasmtime-wasi = { path = "crates/wasi", version = "2.0.0" } wasmtime-wasi-crypto = { path = "crates/wasi-crypto", version = "2.0.0", optional = true } wasmtime-wasi-nn = { path = "crates/wasi-nn", version = "2.0.0", optional = true } +# dlmalloc = { path = "crates/dlmalloc-rs", version = "0.2.4", features = ['global'] } clap = { version = "3.2.0", features = ["color", "suggestions", "derive"] } anyhow = "1.0.19" target-lexicon = { version = "0.12.0", default-features = false } @@ -37,6 +38,7 @@ libc = "0.2.60" humantime = "2.0.0" once_cell = "1.12" listenfd = "1.0.0" +bitflags = "1.2" [target.'cfg(unix)'.dependencies] rustix = { version = "0.35.6", features = ["mm", "param"] } diff --git a/cranelift/codegen/meta/src/isa/x86.rs b/cranelift/codegen/meta/src/isa/x86.rs index e1acdfca2..52bc2c9df 100644 --- a/cranelift/codegen/meta/src/isa/x86.rs +++ b/cranelift/codegen/meta/src/isa/x86.rs @@ -117,6 +117,14 @@ fn define_settings(shared: &SettingGroup) -> SettingGroup { false, ); + // Intel-defined CPU features, CPUID level 0x00000007:0 (ecx) + let has_pkru = settings.add_bool( + "has_pkru", + "Has support for PKU.", + "PKU: CPUID.00000007H:ECX=0H[bit 3&4]", + true, + ); + let shared_enable_simd = shared.get_bool("enable_simd"); settings.add_predicate("use_ssse3", predicate!(has_ssse3)); @@ -163,6 +171,7 @@ fn define_settings(shared: &SettingGroup) -> SettingGroup { settings.add_predicate("use_popcnt", predicate!(has_popcnt && has_sse42)); settings.add_predicate("use_bmi1", predicate!(has_bmi1)); settings.add_predicate("use_lzcnt", predicate!(has_lzcnt)); + settings.add_predicate("use_pkru", predicate!(has_pkru)); // Some shared boolean values are used in x86 instruction predicates, so we need to group them // in the same TargetIsa, for compatibility with code generated by meta-python. @@ -195,7 +204,11 @@ fn define_settings(shared: &SettingGroup) -> SettingGroup { "Broadwell microarchitecture.", preset!(haswell && has_fma), ); - let skylake = settings.add_preset("skylake", "Skylake microarchitecture.", preset!(broadwell)); + let skylake = settings.add_preset( + "skylake", + "Skylake microarchitecture.", + preset!(broadwell && has_pkru), + ); let cannonlake = settings.add_preset( "cannonlake", "Canon Lake microarchitecture.", diff --git a/cranelift/codegen/meta/src/shared/instructions.rs b/cranelift/codegen/meta/src/shared/instructions.rs index ff65e3766..20fc1127e 100644 --- a/cranelift/codegen/meta/src/shared/instructions.rs +++ b/cranelift/codegen/meta/src/shared/instructions.rs @@ -1930,6 +1930,30 @@ pub(crate) fn define( .operands_out(vec![a]), ); + ig.push( + Inst::new( + "rdmemkey", + r#" + Reading memory key value. + "#, + &formats.binary, + ) + .operands_in(vec![x, y]) + .operands_out(vec![a]), + ); + + ig.push( + Inst::new( + "wrmemkey", + r#" + Writing memory key value. + "#, + &formats.binary, + ) + .operands_in(vec![x, y]) + .operands_out(vec![a]), + ); + let I16or32 = &TypeVar::new( "I16or32", "A scalar or vector integer type with 16- or 32-bit numbers", diff --git a/cranelift/codegen/src/ir/entities.rs b/cranelift/codegen/src/ir/entities.rs index 7418b8446..1ed54df29 100644 --- a/cranelift/codegen/src/ir/entities.rs +++ b/cranelift/codegen/src/ir/entities.rs @@ -211,6 +211,11 @@ impl GlobalValue { None } } + + /// Get a value + pub fn get_number(&self) -> u32 { + self.0 + } } /// An opaque reference to a constant. diff --git a/cranelift/codegen/src/isa/aarch64/lower_inst.rs b/cranelift/codegen/src/isa/aarch64/lower_inst.rs index c15d93bbc..12688f455 100644 --- a/cranelift/codegen/src/isa/aarch64/lower_inst.rs +++ b/cranelift/codegen/src/isa/aarch64/lower_inst.rs @@ -473,6 +473,10 @@ pub(crate) fn lower_insn_to_regs( op ))); } + + Opcode::Rdmemkey | Opcode::Wrmemkey => { + panic!("Memory protection key not supported in arm arch!"); + } } Ok(()) diff --git a/cranelift/codegen/src/isa/s390x/lower.rs b/cranelift/codegen/src/isa/s390x/lower.rs index a78a099aa..8d5980022 100644 --- a/cranelift/codegen/src/isa/s390x/lower.rs +++ b/cranelift/codegen/src/isa/s390x/lower.rs @@ -274,6 +274,10 @@ impl LowerBackend for S390xBackend { | Opcode::IfcmpImm => { panic!("ALU+imm and ALU+carry ops should not appear here!"); } + + Opcode::Rdmemkey | Opcode::Wrmemkey => { + panic!("Memory protection key not supported in s390x arch!"); + } } } diff --git a/cranelift/codegen/src/isa/x64/inst.isle b/cranelift/codegen/src/isa/x64/inst.isle index bef45b9b1..4a6836c59 100644 --- a/cranelift/codegen/src/isa/x64/inst.isle +++ b/cranelift/codegen/src/isa/x64/inst.isle @@ -453,6 +453,11 @@ ;; A memory fence (mfence, lfence or sfence). (Fence (kind FenceKind)) + (PKU (op PkuOpcode) + (src1 Gpr) + (src2 Gpr) + (dst WritableGpr)) + ;; ========================================= ;; Meta-instructions generating no code. @@ -754,6 +759,10 @@ (enum Cmp Test)) +(type PkuOpcode extern + (enum RDPKRU + WRPKRU)) + (type RegMemImm extern (enum (Reg (reg Reg)) @@ -1384,6 +1393,9 @@ ;;;; Helpers for Querying Enabled ISA Extensions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(decl use_pkru (bool) Type) +(extern extractor infallible use_pkru use_pkru) + (decl avx512vl_enabled (bool) Type) (extern extractor infallible avx512vl_enabled avx512vl_enabled) @@ -3890,3 +3902,17 @@ (decl libcall_3 (LibCall Reg Reg Reg) Reg) (extern constructor libcall_3 libcall_3) + +;; Helper for creating `rdpkru` instructions. +(decl rdpkru (Gpr Gpr) Gpr) +(rule (rdpkru src1 src2) + (let ((dst WritableGpr (temp_writable_gpr)) + (_ Unit (emit (MInst.PKU (PkuOpcode.RDPKRU) src1 src2 dst)))) + dst)) + +;; Helper for creating `wrpkru` instructions. +(decl wrpkru (Gpr Gpr) Gpr) +(rule (wrpkru src1 src2) + (let ((dst WritableGpr (temp_writable_gpr)) + (_ Unit (emit (MInst.PKU (PkuOpcode.WRPKRU) src1 src2 dst)))) + dst)) \ No newline at end of file diff --git a/cranelift/codegen/src/isa/x64/inst/args.rs b/cranelift/codegen/src/isa/x64/inst/args.rs index b792e528a..f7c9fc6d4 100644 --- a/cranelift/codegen/src/isa/x64/inst/args.rs +++ b/cranelift/codegen/src/isa/x64/inst/args.rs @@ -800,6 +800,7 @@ pub(crate) enum InstructionSet { AVX512F, AVX512VBMI, AVX512VL, + PKU, } /// Some SSE operations requiring 2 operands r/m and r. @@ -1844,3 +1845,33 @@ pub enum FenceKind { /// `sfence` instruction ("Store Fence") SFence, } + +#[derive(Clone, PartialEq)] +pub enum PkuOpcode { + RDPKRU, + WRPKRU, +} + +impl PkuOpcode { + /// Which `InstructionSet`s support the opcode? + pub(crate) fn available_from(&self) -> SmallVec<[InstructionSet; 2]> { + match self { + PkuOpcode::RDPKRU | PkuOpcode::WRPKRU => smallvec![InstructionSet::PKU], + } + } +} + +impl fmt::Debug for PkuOpcode { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + match self { + PkuOpcode::RDPKRU => write!(fmt, "rdpkru"), + PkuOpcode::WRPKRU => write!(fmt, "wrpkru"), + } + } +} + +impl fmt::Display for PkuOpcode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(self, f) + } +} diff --git a/cranelift/codegen/src/isa/x64/inst/emit.rs b/cranelift/codegen/src/isa/x64/inst/emit.rs index e51e7e29c..08e7bf046 100644 --- a/cranelift/codegen/src/isa/x64/inst/emit.rs +++ b/cranelift/codegen/src/isa/x64/inst/emit.rs @@ -126,6 +126,7 @@ pub(crate) fn emit( InstructionSet::AVX512F => info.isa_flags.has_avx512f(), InstructionSet::AVX512VBMI => info.isa_flags.has_avx512vbmi(), InstructionSet::AVX512VL => info.isa_flags.has_avx512vl(), + InstructionSet::PKU => info.isa_flags.has_pkru(), } }; @@ -3194,6 +3195,51 @@ pub(crate) fn emit( Inst::DummyUse { .. } => { // Nothing. } + + Inst::PKU { + op, + src1, + src2, + dst, + } => { + let src = allocs.next(src1.to_reg()); + let edx = allocs.next(src2.to_reg()); + let _dst = allocs.next(dst.to_reg().to_reg()); + + // xor %ecx, %ecx + let xorecx = Inst::alu_rmi_r( + OperandSize::Size32, + AluRmiROpcode::Xor, + RegMemImm::reg(regs::rcx()), + Writable::from_reg(regs::rcx()), + ); + xorecx.emit(&[], sink, info, state); + + // xor %edx, %edx + let xoredx = Inst::alu_rmi_r( + OperandSize::Size32, + AluRmiROpcode::Xor, + RegMemImm::reg(edx), + Writable::from_reg(edx), + ); + xoredx.emit(&[], sink, info, state); + + // mov %src, %eax + if let PkuOpcode::WRPKRU = op { + let size = OperandSize::Size32; + let src = Gpr::new(src).unwrap(); + let dst = WritableGpr::from_writable_reg(Writable::from_reg(regs::rax())).unwrap(); + Inst::MovRR { size, src, dst }.emit(&[], sink, info, state); + } + + // rdpkru / wrpkru + sink.put1(0x0F); + sink.put1(0x01); + match op { + PkuOpcode::RDPKRU => sink.put1(0xEE), + PkuOpcode::WRPKRU => sink.put1(0xEF), + } + } } state.clear_post_insn(); diff --git a/cranelift/codegen/src/isa/x64/inst/mod.rs b/cranelift/codegen/src/isa/x64/inst/mod.rs index 9f67a7ef3..c90ede78d 100644 --- a/cranelift/codegen/src/isa/x64/inst/mod.rs +++ b/cranelift/codegen/src/isa/x64/inst/mod.rs @@ -138,6 +138,8 @@ impl Inst { | Inst::XmmRmREvex3 { op, .. } => op.available_from(), Inst::XmmRmRVex { op, .. } => op.available_from(), + + Inst::PKU { op, .. } => op.available_from(), } } } @@ -1616,6 +1618,16 @@ impl PrettyPrint for Inst { let reg = pretty_print_reg(*reg, 8, allocs); format!("dummy_use {}", reg) } + + Inst::PKU { + op, + src1: _, + src2: _, + dst: _, + } => match op { + PkuOpcode::RDPKRU => "rdpkru".to_string(), + PkuOpcode::WRPKRU => "wrpkru".to_string(), + }, } } } @@ -2106,6 +2118,24 @@ fn x64_get_operands VReg>(inst: &Inst, collector: &mut OperandCol Inst::DummyUse { reg } => { collector.reg_use(*reg); } + + Inst::PKU { + op, + src1, + src2, + dst, + } => match op { + PkuOpcode::RDPKRU => { + collector.reg_fixed_use(src1.to_reg(), regs::rcx()); + collector.reg_fixed_use(src2.to_reg(), regs::rdx()); + collector.reg_fixed_def(dst.to_writable_reg(), regs::rax()); + } + PkuOpcode::WRPKRU => { + collector.reg_fixed_use(src1.to_reg(), regs::rax()); + collector.reg_fixed_use(src2.to_reg(), regs::rdx()); + collector.reg_def(dst.to_writable_reg()); + } + }, } } diff --git a/cranelift/codegen/src/isa/x64/lower.isle b/cranelift/codegen/src/isa/x64/lower.isle index 72b82d271..cc51c6303 100644 --- a/cranelift/codegen/src/isa/x64/lower.isle +++ b/cranelift/codegen/src/isa/x64/lower.isle @@ -3764,3 +3764,12 @@ (rule (lower (nop)) (invalid_reg)) +;; Rules for `rdmemkey` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(rule (lower (rdmemkey x y)) + (rdpkru x y)) + +;; Rules for `wrmemkey` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(rule (lower (wrmemkey x y)) + (wrpkru x y)) \ No newline at end of file diff --git a/cranelift/codegen/src/isa/x64/lower.rs b/cranelift/codegen/src/isa/x64/lower.rs index 1f151800b..f642b1096 100644 --- a/cranelift/codegen/src/isa/x64/lower.rs +++ b/cranelift/codegen/src/isa/x64/lower.rs @@ -470,7 +470,9 @@ fn lower_insn_to_regs( | Opcode::TlsValue | Opcode::SqmulRoundSat | Opcode::Uunarrow - | Opcode::Nop => { + | Opcode::Nop + | Opcode::Rdmemkey + | Opcode::Wrmemkey => { let ty = if outputs.len() > 0 { Some(ctx.output_ty(insn, 0)) } else { diff --git a/cranelift/codegen/src/isa/x64/lower/isle.rs b/cranelift/codegen/src/isa/x64/lower/isle.rs index a39db95c8..266e8d4e5 100644 --- a/cranelift/codegen/src/isa/x64/lower/isle.rs +++ b/cranelift/codegen/src/isa/x64/lower/isle.rs @@ -251,6 +251,11 @@ impl Context for IsleContext<'_, '_, MInst, Flags, IsaFlags, 6> { self.isa_flags.use_sse41() } + #[inline] + fn use_pkru(&mut self, _: Type) -> bool { + self.isa_flags.use_pkru() + } + #[inline] fn imm8_from_value(&mut self, val: Value) -> Option { let inst = self.lower_ctx.dfg().value_def(val).inst()?; diff --git a/cranelift/codegen/src/machinst/buffer.rs b/cranelift/codegen/src/machinst/buffer.rs index c4eb5dd2d..3a64ba044 100644 --- a/cranelift/codegen/src/machinst/buffer.rs +++ b/cranelift/codegen/src/machinst/buffer.rs @@ -693,7 +693,7 @@ impl MachBuffer { // (end of buffer) self.data.truncate(b.start as usize); self.fixup_records.truncate(b.fixup); - while let Some(mut last_srcloc) = self.srclocs.last_mut() { + while let Some(last_srcloc) = self.srclocs.last_mut() { if last_srcloc.end <= b.start { break; } diff --git a/cranelift/interpreter/src/step.rs b/cranelift/interpreter/src/step.rs index 280c2c91f..e07860a8e 100644 --- a/cranelift/interpreter/src/step.rs +++ b/cranelift/interpreter/src/step.rs @@ -1193,6 +1193,9 @@ where Opcode::GetFramePointer => unimplemented!("GetFramePointer"), Opcode::GetStackPointer => unimplemented!("GetStackPointer"), Opcode::GetReturnAddress => unimplemented!("GetReturnAddress"), + Opcode::Rdmemkey | Opcode::Wrmemkey => { + unimplemented!("memory protection key"); + } }) } diff --git a/cranelift/native/src/lib.rs b/cranelift/native/src/lib.rs index c9ca7a288..182980e9e 100644 --- a/cranelift/native/src/lib.rs +++ b/cranelift/native/src/lib.rs @@ -119,6 +119,9 @@ pub fn builder_with_options(infer_native_flags: bool) -> Result Result( | Operator::F64x2RelaxedMax => { return Err(wasm_unsupported!("proposed relaxed-simd operator {:?}", op)); } + + Operator::Rdpkru => { + let (arg1, arg2) = state.pop2(); + state.push1(builder.ins().rdmemkey(arg1, arg2)); + } + Operator::Wrpkru => { + let (arg1, arg2) = state.pop2(); + state.push1(builder.ins().wrmemkey(arg1, arg2)); + } }; Ok(()) } diff --git a/cranelift/wasm/src/environ/spec.rs b/cranelift/wasm/src/environ/spec.rs index bfdaa2b42..eb6762d44 100644 --- a/cranelift/wasm/src/environ/spec.rs +++ b/cranelift/wasm/src/environ/spec.rs @@ -96,7 +96,8 @@ pub trait FuncEnvironment: TargetEnvironment { /// Called after the locals for a function have been parsed, and the number /// of variables defined by this function is provided. fn after_locals(&mut self, num_locals_defined: usize) { - drop(num_locals_defined); + // drop(num_locals_defined); + let _ = num_locals_defined; } /// Set up the necessary preamble definitions in `func` to access the global variable @@ -517,7 +518,8 @@ pub trait ModuleEnvironment<'data> { /// Translates a type index to its signature index, only called for type /// indices which point to functions. fn type_to_signature(&self, index: TypeIndex) -> WasmResult { - drop(index); + // drop(index); + let _ = index; Err(WasmError::Unsupported("module linking".to_string())) } @@ -558,7 +560,8 @@ pub trait ModuleEnvironment<'data> { module: &'data str, field: &'data str, ) -> WasmResult<()> { - drop((tag, module, field)); + // drop((tag, module, field)); + let _ = (tag, module, field); Err(WasmError::Unsupported("wasm tags".to_string())) } @@ -610,7 +613,8 @@ pub trait ModuleEnvironment<'data> { /// Declares an tag to the environment fn declare_tag(&mut self, tag: Tag) -> WasmResult<()> { - drop(tag); + // drop(tag); + let _ = tag; Err(WasmError::Unsupported("wasm tags".to_string())) } @@ -645,7 +649,8 @@ pub trait ModuleEnvironment<'data> { /// Declares an tag export to the environment. fn declare_tag_export(&mut self, tag_index: TagIndex, name: &'data str) -> WasmResult<()> { - drop((tag_index, name)); + // drop((tag_index, name)); + let _ = (tag_index, name); Err(WasmError::Unsupported("wasm tags".to_string())) } @@ -708,7 +713,8 @@ pub trait ModuleEnvironment<'data> { /// Indicates how many functions the code section reports and the byte /// offset of where the code sections starts. fn reserve_function_bodies(&mut self, bodies: u32, code_section_offset: u64) { - drop((bodies, code_section_offset)); + // drop((bodies, code_section_offset)); + let _ = (bodies, code_section_offset); } /// Provides the contents of a function body. diff --git a/crates/cranelift/Cargo.toml b/crates/cranelift/Cargo.toml index 4ade29328..70d1f12e4 100644 --- a/crates/cranelift/Cargo.toml +++ b/crates/cranelift/Cargo.toml @@ -19,7 +19,7 @@ cranelift-codegen = { path = "../../cranelift/codegen", version = "0.89.0" } cranelift-frontend = { path = "../../cranelift/frontend", version = "0.89.0" } cranelift-entity = { path = "../../cranelift/entity", version = "0.89.0" } cranelift-native = { path = "../../cranelift/native", version = "0.89.0" } -wasmparser = "0.89.0" +wasmparser = { path = "../wasmparser", version = "0.89.0"} target-lexicon = "0.12" gimli = { version = "0.26.0", default-features = false, features = ['read', 'std'] } object = { version = "0.29.0", default-features = false, features = ['write'] } diff --git a/crates/cranelift/src/func_environ.rs b/crates/cranelift/src/func_environ.rs index 59822f415..877192aa6 100644 --- a/crates/cranelift/src/func_environ.rs +++ b/crates/cranelift/src/func_environ.rs @@ -1455,6 +1455,7 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m global_type: pointer_type, readonly: readonly_base, }); + // println!("base: {}, base_offset: {}", ptr.get_number(), base_offset); Ok(func.create_heap(ir::HeapData { base: heap_base, min_size: 0.into(), diff --git a/crates/environ/Cargo.toml b/crates/environ/Cargo.toml index 47cc2184b..25296b2e2 100644 --- a/crates/environ/Cargo.toml +++ b/crates/environ/Cargo.toml @@ -14,7 +14,7 @@ edition = "2021" anyhow = "1.0" cranelift-entity = { path = "../../cranelift/entity", version = "0.89.0" } wasmtime-types = { path = "../types", version = "2.0.0" } -wasmparser = "0.89.0" +wasmparser = { path = "../wasmparser", version = "0.89.0"} indexmap = { version = "1.0.2", features = ["serde-1"] } thiserror = "1.0.4" serde = { version = "1.0.94", features = ["derive"] } diff --git a/crates/environ/src/module.rs b/crates/environ/src/module.rs index 23d352f5b..c1af938b9 100644 --- a/crates/environ/src/module.rs +++ b/crates/environ/src/module.rs @@ -257,6 +257,7 @@ impl ModuleTranslation<'_> { info.min_addr = info.min_addr.min(init.offset); info.max_addr = info.max_addr.max(init.offset + data_len); info.segments.push((idx, init.clone())); + // println!("data_len: {}, offset: {}, max_addr: {}, min_addr: {}", data_len, init.offset, info.max_addr, info.min_addr); } idx += 1; true diff --git a/crates/environ/src/module_environ.rs b/crates/environ/src/module_environ.rs index b029084ae..8beea5f8c 100644 --- a/crates/environ/src/module_environ.rs +++ b/crates/environ/src/module_environ.rs @@ -339,6 +339,14 @@ impl<'a, 'data> ModuleEnvironment<'a, 'data> { ))); } }; + // match initializer { + // GlobalInit::I32Const(value) => { + // if value == 65536 { + // initializer = GlobalInit::I32Const(value - 4096); + // } + // } + // _ => {} + // } let ty = Global::new(ty, initializer)?; self.result.module.globals.push(ty); } @@ -518,6 +526,7 @@ impl<'a, 'data> ModuleEnvironment<'a, 'data> { _ => unreachable!(), }; + const PAGE_SIZE: usize = 4096; let cnt = usize::try_from(data.get_count()).unwrap(); initializers.reserve_exact(cnt); self.result.data.reserve_exact(cnt); @@ -544,15 +553,31 @@ impl<'a, 'data> ModuleEnvironment<'a, 'data> { *total += range.end - range.start; Ok(range) }; + let mk_guard_range = |total: &mut u32| -> Result<_, WasmError> { + let range = u32::try_from(data.len() + PAGE_SIZE) + .ok() + .and_then(|size| { + let start = *total; + let end = start.checked_add(size)?; + Some(start..end) + }) + .ok_or_else(|| { + WasmError::Unsupported(format!( + "more than 4 gigabytes of data in wasm module", + )) + })?; + *total += range.end - range.start; + Ok(range) + }; match kind { DataKind::Active { memory_index, offset_expr, } => { - let range = mk_range(&mut self.result.total_data)?; + // let range = mk_range(&mut self.result.total_data)?; let memory_index = MemoryIndex::from_u32(memory_index); let mut offset_expr_reader = offset_expr.get_binary_reader(); - let (base, offset) = match offset_expr_reader.read_operator()? { + let (base, old_offset) = match offset_expr_reader.read_operator()? { Operator::I32Const { value } => (None, value as u64), Operator::I64Const { value } => (None, value as u64), Operator::GlobalGet { global_index } => { @@ -565,14 +590,29 @@ impl<'a, 'data> ModuleEnvironment<'a, 'data> { ))); } }; - - initializers.push(MemoryInitializer { - memory_index, - base, - offset, - data: range, - }); - self.result.data.push(data.into()); + if index == 0 && old_offset > PAGE_SIZE.try_into().unwrap() { + let offset = old_offset - PAGE_SIZE as u64; + let range = mk_guard_range(&mut self.result.total_data)?; + initializers.push(MemoryInitializer { + memory_index, + base, + offset, + data: range, + }); + let guard_page = &[1u8; PAGE_SIZE]; + let new_data = [guard_page, data].concat(); + self.result.data.push(new_data.into()); + } else { + let offset = old_offset; + let range = mk_range(&mut self.result.total_data)?; + initializers.push(MemoryInitializer { + memory_index, + base, + offset, + data: range, + }); + self.result.data.push(data.into()); + } } DataKind::Passive => { let data_index = DataIndex::from_u32(index as u32); diff --git a/crates/jit/src/code_memory.rs b/crates/jit/src/code_memory.rs index 08ee895f7..a8916e97f 100644 --- a/crates/jit/src/code_memory.rs +++ b/crates/jit/src/code_memory.rs @@ -90,7 +90,7 @@ impl CodeMemory { pub fn publish(&mut self, enable_branch_protection: bool) -> Result> { assert!(!self.published); self.published = true; - + // println!("JIT publish"); let mut ret = Publish { obj: File::parse(&self.mmap[..]) .with_context(|| "failed to parse internal compilation artifact")?, diff --git a/crates/runtime/src/cow.rs b/crates/runtime/src/cow.rs index a4364e6f3..da0ea5954 100644 --- a/crates/runtime/src/cow.rs +++ b/crates/runtime/src/cow.rs @@ -116,6 +116,10 @@ impl MemoryImage { let end = start + mmap.len(); let data_start = data.as_ptr() as usize; let data_end = data_start + data.len(); + // println!( + // "MemoryImage new data_start: 0x{:x}, data_end: 0x{:x}", + // data_start, data_end + // ); assert!(start <= data_start && data_end <= end); assert_eq!((start as u32) % page_size, 0); assert_eq!((data_start as u32) % page_size, 0); @@ -456,7 +460,19 @@ impl MemoryImageSlot { ) .map_err(|e| InstantiationError::Resource(e.into()))?; assert_eq!(ptr as usize, self.base + image.linear_memory_offset); + // let start = image.linear_memory_offset; + // let end = start + 4096; + // let result = + // self.set_protection(start..end, rustix::mm::MprotectFlags::empty()); + // match result { + // Ok(_) => {} + // Err(_) => {} + // } } + // println!( + // "instantiate linear_memory_offset: {}, len: {}", + // image.linear_memory_offset, image.len + // ); } } diff --git a/crates/runtime/src/externref.rs b/crates/runtime/src/externref.rs index cc90b48ac..4227735f9 100644 --- a/crates/runtime/src/externref.rs +++ b/crates/runtime/src/externref.rs @@ -225,7 +225,7 @@ impl Drop for VMExternRef { atomic::fence(Ordering::Acquire); // Drop our live reference to `data` before we drop it itself. - drop(data); + // drop(data); unsafe { VMExternData::drop_and_dealloc(self.0); } diff --git a/crates/runtime/src/instance/allocator.rs b/crates/runtime/src/instance/allocator.rs index b52e8aa83..5b448c140 100644 --- a/crates/runtime/src/instance/allocator.rs +++ b/crates/runtime/src/instance/allocator.rs @@ -132,7 +132,8 @@ pub enum FiberStackError { pub unsafe trait InstanceAllocator: Send + Sync { /// Validates that a module is supported by the allocator. fn validate(&self, module: &Module) -> Result<()> { - drop(module); + // drop(module); + let _ = module; Ok(()) } @@ -140,7 +141,8 @@ pub unsafe trait InstanceAllocator: Send + Sync { /// /// This method allows the instance allocator control over tunables passed to a `wasmtime_jit::Compiler`. fn adjust_tunables(&self, tunables: &mut wasmtime_environ::Tunables) { - drop(tunables); + // drop(tunables); + let _ = tunables; } /// Allocates an instance for the given allocation request. @@ -436,7 +438,8 @@ pub struct OnDemandInstanceAllocator { impl OnDemandInstanceAllocator { /// Creates a new on-demand instance allocator. pub fn new(mem_creator: Option>, stack_size: usize) -> Self { - drop(stack_size); // suppress unused warnings w/o async feature + // drop(stack_size); // suppress unused warnings w/o async feature + let _ = stack_size; Self { mem_creator, #[cfg(feature = "async")] diff --git a/crates/runtime/src/instance/allocator/pooling.rs b/crates/runtime/src/instance/allocator/pooling.rs index 3082c3ae8..7a0206ecb 100644 --- a/crates/runtime/src/instance/allocator/pooling.rs +++ b/crates/runtime/src/instance/allocator/pooling.rs @@ -1040,8 +1040,9 @@ impl PoolingInstanceAllocator { let instances = InstancePool::new(strategy, &instance_limits, tunables)?; - drop(stack_size); // suppress unused warnings w/o async feature - drop(async_stack_zeroing); // suppress unused warnings w/o async feature + // drop(stack_size); // suppress unused warnings w/o async feature + // drop(async_stack_zeroing); // suppress unused warnings w/o async feature + let _ = (stack_size, async_stack_zeroing); Ok(Self { instances: instances, diff --git a/crates/runtime/src/lib.rs b/crates/runtime/src/lib.rs index 399f209e9..9b566155e 100644 --- a/crates/runtime/src/lib.rs +++ b/crates/runtime/src/lib.rs @@ -43,6 +43,7 @@ mod mmap_vec; mod table; mod traphandlers; mod vmcontext; +mod pku; pub mod debug_builtins; pub mod libcalls; @@ -75,6 +76,7 @@ pub use crate::vmcontext::{ VMOpaqueContext, VMRuntimeLimits, VMSharedSignatureIndex, VMTableDefinition, VMTableImport, VMTrampoline, ValRaw, }; +pub use crate::pku::Pku; mod module_id; pub use module_id::{CompiledModuleId, CompiledModuleIdAllocator}; diff --git a/crates/runtime/src/pku.rs b/crates/runtime/src/pku.rs new file mode 100644 index 000000000..e08a83ffb --- /dev/null +++ b/crates/runtime/src/pku.rs @@ -0,0 +1,90 @@ +//! Memory isolation of pku + +use crate::vmcontext::VMMemoryDefinition; +use libc::{self, SYS_pkey_alloc, SYS_pkey_mprotect}; +use std::arch::asm; + +/// A simple struct of pku +#[derive(Debug)] +pub struct Pku {} + +const PKEY_DISABLE_ACCESS: i32 = 1; +const PKEY_DISABLE_WRITE: i32 = 2; + +impl Pku { + /// Construct a new init instance of 'Pku'. + pub fn new() -> Self { + Self {} + } + + /// Change memory protection key protection permission on the specified page. + pub fn pkey_mprotect(vm: &VMMemoryDefinition, start: usize, len: usize, prot: i64, pkey: i64) { + unsafe { + if libc::syscall(SYS_pkey_mprotect, vm.base.add(start), len, prot, pkey) == -1 { + println!("error in libc::syscall SYS_pkey_mprotect"); + } + } + } + + /// Alloc memory protection key and set protection permission on the specified page. + pub fn pkey_isolated(vm: &VMMemoryDefinition, start: usize, len: usize, prot: i64) -> i64 { + unsafe { + let pkey = libc::syscall(SYS_pkey_alloc, 0, 0); + if pkey < 0 { + println!("error in libc::syscall SYS_pkey_alloc"); + } + Self::pkey_mprotect(vm, start, len, prot, pkey); + return pkey; + } + } + + /// Read pkru value. + pub fn rdpkru() -> i32 { + let ecx = 0; + let mut pkru: i32; + + unsafe { + asm!(".byte 0x0f,0x01,0xee;", + out("eax") pkru, + in("ecx") ecx); + } + + return pkru; + } + + /// Write pkru value. + pub fn wrpkru(pkru: i32) { + let ecx = 0; + let edx = 0; + + unsafe { + asm!(".byte 0x0f,0x01,0xef;", + in("eax") pkru, + in("ecx") ecx, + in("edx") edx); + } + } + + /// This will go out and modify PKRU register to set the access rights. + pub fn set_pkey(pkey: i64, prot: i32) { + let pkey_shift = pkey * 2; + let mut new_pkru_bits = 0; + + if prot & PKEY_DISABLE_ACCESS != 0 { + new_pkru_bits |= PKEY_DISABLE_ACCESS; + } + if prot & PKEY_DISABLE_WRITE != 0 { + new_pkru_bits |= PKEY_DISABLE_WRITE; + } + + /* Shift the bits in to the correct place in PKRU for pkey: */ + new_pkru_bits <<= pkey_shift; + + /* Get old PKRU and mask off any old bits in place: */ + let mut old_pkru = Pku::rdpkru(); + old_pkru &= !((PKEY_DISABLE_ACCESS | PKEY_DISABLE_WRITE) << pkey_shift); + + /* Write old part along with new part: */ + Pku::wrpkru(old_pkru | new_pkru_bits); + } +} diff --git a/crates/runtime/src/traphandlers.rs b/crates/runtime/src/traphandlers.rs index a08a0507f..cc62273b6 100644 --- a/crates/runtime/src/traphandlers.rs +++ b/crates/runtime/src/traphandlers.rs @@ -181,7 +181,7 @@ where F: FnMut(*mut VMContext), { let limits = (*caller).instance().runtime_limits(); - + // println!("before catch_traps"); let result = CallThreadState::new(signal_handler, capture_backtrace, *limits).with(|cx| { wasmtime_setjmp( cx.jmp_buf.as_ptr(), @@ -190,7 +190,7 @@ where caller, ) }); - + // println!("after catch_traps"); return match result { Ok(x) => Ok(x), Err((UnwindReason::Trap(reason), backtrace)) => Err(Box::new(Trap { reason, backtrace })), @@ -201,7 +201,9 @@ where where F: FnMut(*mut VMContext), { + // println!("before call_closure"); unsafe { (*(payload as *mut F))(caller) } + // println!("after call_closure"); } } diff --git a/crates/runtime/src/traphandlers/unix.rs b/crates/runtime/src/traphandlers/unix.rs index be3b13d14..1339eb31a 100644 --- a/crates/runtime/src/traphandlers/unix.rs +++ b/crates/runtime/src/traphandlers/unix.rs @@ -241,7 +241,8 @@ unsafe fn get_pc_and_fp(cx: *mut libc::c_void, _signum: libc::c_int) -> (*const unsafe fn set_pc(cx: *mut libc::c_void, pc: usize, arg1: usize) { cfg_if::cfg_if! { if #[cfg(not(target_os = "macos"))] { - drop((cx, pc, arg1)); + // drop((cx, pc, arg1)); + let _ = (cx, pc, arg1); unreachable!(); // not used on these platforms } else if #[cfg(target_arch = "x86_64")] { let cx = &mut *(cx as *mut libc::ucontext_t); diff --git a/crates/types/Cargo.toml b/crates/types/Cargo.toml index 502808cf6..fcd452333 100644 --- a/crates/types/Cargo.toml +++ b/crates/types/Cargo.toml @@ -12,4 +12,4 @@ edition = "2021" cranelift-entity = { path = "../../cranelift/entity", version = "0.89.0", features = ['enable-serde'] } serde = { version = "1.0.94", features = ["derive"] } thiserror = "1.0.4" -wasmparser = { version = "0.89.0", default-features = false } +wasmparser = { path = "../../crates/wasmparser", version = "0.89.0", default-features = false } diff --git a/crates/wasi-common/Cargo.toml b/crates/wasi-common/Cargo.toml index 7a3cb5aa4..20d265925 100644 --- a/crates/wasi-common/Cargo.toml +++ b/crates/wasi-common/Cargo.toml @@ -25,6 +25,7 @@ tracing = "0.1.19" cap-std = "0.25.3" cap-rand = "0.25.3" bitflags = "1.2" +libc = "0.2.60" [target.'cfg(unix)'.dependencies] rustix = { version = "0.35.6", features = ["fs"] } diff --git a/crates/wasi-common/cap-std-sync/src/file.rs b/crates/wasi-common/cap-std-sync/src/file.rs index 8fe395fda..317a2fe5d 100644 --- a/crates/wasi-common/cap-std-sync/src/file.rs +++ b/crates/wasi-common/cap-std-sync/src/file.rs @@ -40,10 +40,18 @@ impl WasiFile for File { self.0.sync_data()?; Ok(()) } + fn datasync_sync(&mut self) -> Result<(), Error> { + self.0.sync_data()?; + Ok(()) + } async fn sync(&mut self) -> Result<(), Error> { self.0.sync_all()?; Ok(()) } + fn sync_sync(&mut self) -> Result<(), Error> { + self.0.sync_all()?; + Ok(()) + } async fn get_filetype(&mut self) -> Result { let meta = self.0.metadata()?; Ok(filetype_from(&meta.file_type())) @@ -64,6 +72,18 @@ impl WasiFile for File { self.0.set_fd_flags(set_fd_flags)?; Ok(()) } + fn set_fdflags_sync(&mut self, fdflags: FdFlags) -> Result<(), Error> { + if fdflags.intersects( + wasi_common::file::FdFlags::DSYNC + | wasi_common::file::FdFlags::SYNC + | wasi_common::file::FdFlags::RSYNC, + ) { + return Err(Error::invalid_argument().context("cannot set DSYNC, SYNC, or RSYNC flag")); + } + let set_fd_flags = self.0.new_set_fd_flags(to_sysif_fdflags(fdflags))?; + self.0.set_fd_flags(set_fd_flags)?; + Ok(()) + } async fn get_filestat(&mut self) -> Result { let meta = self.0.metadata()?; Ok(Filestat { @@ -81,14 +101,26 @@ impl WasiFile for File { self.0.set_len(size)?; Ok(()) } + fn set_filestat_size_sync(&mut self, size: u64) -> Result<(), Error> { + self.0.set_len(size)?; + Ok(()) + } async fn advise(&mut self, offset: u64, len: u64, advice: Advice) -> Result<(), Error> { self.0.advise(offset, len, convert_advice(advice))?; Ok(()) } + fn advise_sync(&mut self, offset: u64, len: u64, advice: Advice) -> Result<(), Error> { + self.0.advise(offset, len, convert_advice(advice))?; + Ok(()) + } async fn allocate(&mut self, offset: u64, len: u64) -> Result<(), Error> { self.0.allocate(offset, len)?; Ok(()) } + fn allocate_sync(&mut self, offset: u64, len: u64) -> Result<(), Error> { + self.0.allocate(offset, len)?; + Ok(()) + } async fn set_times( &mut self, atime: Option, @@ -102,6 +134,10 @@ impl WasiFile for File { let n = self.0.read_vectored(bufs)?; Ok(n.try_into()?) } + fn read_vectored_sync<'a>(&mut self, bufs: &mut [io::IoSliceMut<'a>]) -> Result { + let n = self.0.read_vectored(bufs)?; + Ok(n.try_into()?) + } async fn read_vectored_at<'a>( &mut self, bufs: &mut [io::IoSliceMut<'a>], @@ -110,10 +146,22 @@ impl WasiFile for File { let n = self.0.read_vectored_at(bufs, offset)?; Ok(n.try_into()?) } + fn read_vectored_at_sync<'a>( + &mut self, + bufs: &mut [io::IoSliceMut<'a>], + offset: u64, + ) -> Result { + let n = self.0.read_vectored_at(bufs, offset)?; + Ok(n.try_into()?) + } async fn write_vectored<'a>(&mut self, bufs: &[io::IoSlice<'a>]) -> Result { let n = self.0.write_vectored(bufs)?; Ok(n.try_into()?) } + fn write_vectored_sync<'a>(&mut self, bufs: &[io::IoSlice<'a>]) -> Result { + let n = self.0.write_vectored(bufs)?; + Ok(n.try_into()?) + } async fn write_vectored_at<'a>( &mut self, bufs: &[io::IoSlice<'a>], @@ -122,9 +170,20 @@ impl WasiFile for File { let n = self.0.write_vectored_at(bufs, offset)?; Ok(n.try_into()?) } + fn write_vectored_at_sync<'a>( + &mut self, + bufs: &[io::IoSlice<'a>], + offset: u64, + ) -> Result { + let n = self.0.write_vectored_at(bufs, offset)?; + Ok(n.try_into()?) + } async fn seek(&mut self, pos: std::io::SeekFrom) -> Result { Ok(self.0.seek(pos)?) } + fn seek_sync(&mut self, pos: std::io::SeekFrom) -> Result { + Ok(self.0.seek(pos)?) + } async fn peek(&mut self, buf: &mut [u8]) -> Result { let n = self.0.peek(buf)?; Ok(n.try_into()?) diff --git a/crates/wasi-common/cap-std-sync/src/stdio.rs b/crates/wasi-common/cap-std-sync/src/stdio.rs index d53702b03..14114a6e0 100644 --- a/crates/wasi-common/cap-std-sync/src/stdio.rs +++ b/crates/wasi-common/cap-std-sync/src/stdio.rs @@ -51,6 +51,10 @@ impl WasiFile for Stdin { let n = (&*self.0.as_filelike_view::()).read_vectored(bufs)?; Ok(n.try_into().map_err(|_| Error::range())?) } + fn read_vectored_sync<'a>(&mut self, bufs: &mut [io::IoSliceMut<'a>]) -> Result { + let n = (&*self.0.as_filelike_view::()).read_vectored(bufs)?; + Ok(n.try_into().map_err(|_| Error::range())?) + } async fn read_vectored_at<'a>( &mut self, _bufs: &mut [io::IoSliceMut<'a>], @@ -130,6 +134,10 @@ macro_rules! wasi_file_write_impl { let n = (&*self.0.as_filelike_view::()).write_vectored(bufs)?; Ok(n.try_into().map_err(|c| Error::range().context(c))?) } + fn write_vectored_sync<'a>(&mut self, bufs: &[io::IoSlice<'a>]) -> Result { + let n = (&*self.0.as_filelike_view::()).write_vectored(bufs)?; + Ok(n.try_into().map_err(|c| Error::range().context(c))?) + } async fn write_vectored_at<'a>( &mut self, _bufs: &[io::IoSlice<'a>], diff --git a/crates/wasi-common/src/file.rs b/crates/wasi-common/src/file.rs index 8d4bf6a45..432860c6e 100644 --- a/crates/wasi-common/src/file.rs +++ b/crates/wasi-common/src/file.rs @@ -48,19 +48,24 @@ pub trait WasiFile: Send + Sync { async fn datasync(&mut self) -> Result<(), Error> { Ok(()) } - + fn datasync_sync(&mut self) -> Result<(), Error> { + Ok(()) + } async fn sync(&mut self) -> Result<(), Error> { Ok(()) } - + fn sync_sync(&mut self) -> Result<(), Error> { + Ok(()) + } async fn get_fdflags(&mut self) -> Result { Ok(FdFlags::empty()) } - async fn set_fdflags(&mut self, _flags: FdFlags) -> Result<(), Error> { Err(Error::badf()) } - + fn set_fdflags_sync(&mut self, _flags: FdFlags) -> Result<(), Error> { + Err(Error::badf()) + } async fn get_filestat(&mut self) -> Result { Ok(Filestat { device_id: 0, @@ -77,15 +82,21 @@ pub trait WasiFile: Send + Sync { async fn set_filestat_size(&mut self, _size: u64) -> Result<(), Error> { Err(Error::badf()) } - + fn set_filestat_size_sync(&mut self, _size: u64) -> Result<(), Error> { + Err(Error::badf()) + } async fn advise(&mut self, _offset: u64, _len: u64, _advice: Advice) -> Result<(), Error> { Err(Error::badf()) } - + fn advise_sync(&mut self, _offset: u64, _len: u64, _advice: Advice) -> Result<(), Error> { + Err(Error::badf()) + } async fn allocate(&mut self, _offset: u64, _len: u64) -> Result<(), Error> { Err(Error::badf()) } - + fn allocate_sync(&mut self, _offset: u64, _len: u64) -> Result<(), Error> { + Err(Error::badf()) + } async fn set_times( &mut self, _atime: Option, @@ -100,7 +111,12 @@ pub trait WasiFile: Send + Sync { ) -> Result { Err(Error::badf()) } - + fn read_vectored_sync<'a>( + &mut self, + _bufs: &mut [std::io::IoSliceMut<'a>], + ) -> Result { + Err(Error::badf()) + } async fn read_vectored_at<'a>( &mut self, _bufs: &mut [std::io::IoSliceMut<'a>], @@ -108,11 +124,19 @@ pub trait WasiFile: Send + Sync { ) -> Result { Err(Error::badf()) } - + fn read_vectored_at_sync<'a>( + &mut self, + _bufs: &mut [std::io::IoSliceMut<'a>], + _offset: u64, + ) -> Result { + Err(Error::badf()) + } async fn write_vectored<'a>(&mut self, _bufs: &[std::io::IoSlice<'a>]) -> Result { Err(Error::badf()) } - + fn write_vectored_sync<'a>(&mut self, _bufs: &[std::io::IoSlice<'a>]) -> Result { + Err(Error::badf()) + } async fn write_vectored_at<'a>( &mut self, _bufs: &[std::io::IoSlice<'a>], @@ -120,11 +144,19 @@ pub trait WasiFile: Send + Sync { ) -> Result { Err(Error::badf()) } - + fn write_vectored_at_sync<'a>( + &mut self, + _bufs: &[std::io::IoSlice<'a>], + _offset: u64, + ) -> Result { + Err(Error::badf()) + } async fn seek(&mut self, _pos: std::io::SeekFrom) -> Result { Err(Error::badf()) } - + fn seek_sync(&mut self, _pos: std::io::SeekFrom) -> Result { + Err(Error::badf()) + } async fn peek(&mut self, _buf: &mut [u8]) -> Result { Err(Error::badf()) } diff --git a/crates/wasi-common/src/pipe.rs b/crates/wasi-common/src/pipe.rs index a5fceb80a..36b0fc7d6 100644 --- a/crates/wasi-common/src/pipe.rs +++ b/crates/wasi-common/src/pipe.rs @@ -109,6 +109,7 @@ impl WasiFile for ReadPipe { Ok(FileType::Pipe) } async fn read_vectored<'a>(&mut self, bufs: &mut [io::IoSliceMut<'a>]) -> Result { + println!("read_vectored in pipe.rs"); let n = self.borrow().read_vectored(bufs)?; Ok(n.try_into()?) } diff --git a/crates/wasi-common/src/snapshots/preview_0.rs b/crates/wasi-common/src/snapshots/preview_0.rs index 96f86820b..d47317584 100644 --- a/crates/wasi-common/src/snapshots/preview_0.rs +++ b/crates/wasi-common/src/snapshots/preview_0.rs @@ -342,11 +342,13 @@ impl wasi_unstable::WasiUnstable for WasiCtx { argv: &GuestPtr<'a, GuestPtr<'a, u8>>, argv_buf: &GuestPtr<'a, u8>, ) -> Result<(), Error> { - Snapshot1::args_get(self, argv, argv_buf).await + // Snapshot1::args_get(self, argv, argv_buf).await + Snapshot1::args_get(self, argv, argv_buf) } async fn args_sizes_get(&mut self) -> Result<(types::Size, types::Size), Error> { - Snapshot1::args_sizes_get(self).await + // Snapshot1::args_sizes_get(self).await + Snapshot1::args_sizes_get(self) } async fn environ_get<'a>( @@ -354,15 +356,18 @@ impl wasi_unstable::WasiUnstable for WasiCtx { environ: &GuestPtr<'a, GuestPtr<'a, u8>>, environ_buf: &GuestPtr<'a, u8>, ) -> Result<(), Error> { - Snapshot1::environ_get(self, environ, environ_buf).await + // Snapshot1::environ_get(self, environ, environ_buf).await + Snapshot1::environ_get(self, environ, environ_buf) } async fn environ_sizes_get(&mut self) -> Result<(types::Size, types::Size), Error> { - Snapshot1::environ_sizes_get(self).await + // Snapshot1::environ_sizes_get(self).await + Snapshot1::environ_sizes_get(self) } async fn clock_res_get(&mut self, id: types::Clockid) -> Result { - Snapshot1::clock_res_get(self, id.into()).await + // Snapshot1::clock_res_get(self, id.into()).await + Snapshot1::clock_res_get(self, id.into()) } async fn clock_time_get( @@ -370,7 +375,8 @@ impl wasi_unstable::WasiUnstable for WasiCtx { id: types::Clockid, precision: types::Timestamp, ) -> Result { - Snapshot1::clock_time_get(self, id.into(), precision).await + // Snapshot1::clock_time_get(self, id.into(), precision).await + Snapshot1::clock_time_get(self, id.into(), precision) } async fn fd_advise( @@ -380,7 +386,8 @@ impl wasi_unstable::WasiUnstable for WasiCtx { len: types::Filesize, advice: types::Advice, ) -> Result<(), Error> { - Snapshot1::fd_advise(self, fd.into(), offset, len, advice.into()).await + // Snapshot1::fd_advise(self, fd.into(), offset, len, advice.into()).await + Snapshot1::fd_advise(self, fd.into(), offset, len, advice.into()) } async fn fd_allocate( @@ -389,15 +396,18 @@ impl wasi_unstable::WasiUnstable for WasiCtx { offset: types::Filesize, len: types::Filesize, ) -> Result<(), Error> { - Snapshot1::fd_allocate(self, fd.into(), offset, len).await + // Snapshot1::fd_allocate(self, fd.into(), offset, len).await + Snapshot1::fd_allocate(self, fd.into(), offset, len) } async fn fd_close(&mut self, fd: types::Fd) -> Result<(), Error> { - Snapshot1::fd_close(self, fd.into()).await + // Snapshot1::fd_close(self, fd.into()).await + Snapshot1::fd_close(self, fd.into()) } async fn fd_datasync(&mut self, fd: types::Fd) -> Result<(), Error> { - Snapshot1::fd_datasync(self, fd.into()).await + // Snapshot1::fd_datasync(self, fd.into()).await + Snapshot1::fd_datasync(self, fd.into()) } async fn fd_fdstat_get(&mut self, fd: types::Fd) -> Result { @@ -409,7 +419,8 @@ impl wasi_unstable::WasiUnstable for WasiCtx { fd: types::Fd, flags: types::Fdflags, ) -> Result<(), Error> { - Snapshot1::fd_fdstat_set_flags(self, fd.into(), flags.into()).await + // Snapshot1::fd_fdstat_set_flags(self, fd.into(), flags.into()).await + Snapshot1::fd_fdstat_set_flags(self, fd.into(), flags.into()) } async fn fd_fdstat_set_rights( @@ -424,7 +435,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx { fs_rights_base.into(), fs_rights_inheriting.into(), ) - .await + // .await } async fn fd_filestat_get(&mut self, fd: types::Fd) -> Result { @@ -436,7 +447,8 @@ impl wasi_unstable::WasiUnstable for WasiCtx { fd: types::Fd, size: types::Filesize, ) -> Result<(), Error> { - Snapshot1::fd_filestat_set_size(self, fd.into(), size).await + // Snapshot1::fd_filestat_set_size(self, fd.into(), size).await + Snapshot1::fd_filestat_set_size(self, fd.into(), size) } async fn fd_filestat_set_times( @@ -572,7 +584,8 @@ impl wasi_unstable::WasiUnstable for WasiCtx { } async fn fd_prestat_get(&mut self, fd: types::Fd) -> Result { - Ok(Snapshot1::fd_prestat_get(self, fd.into()).await?.into()) + // Ok(Snapshot1::fd_prestat_get(self, fd.into()).await?.into()) + Ok(Snapshot1::fd_prestat_get(self, fd.into())?.into()) } async fn fd_prestat_dir_name<'a>( @@ -581,11 +594,13 @@ impl wasi_unstable::WasiUnstable for WasiCtx { path: &GuestPtr<'a, u8>, path_max_len: types::Size, ) -> Result<(), Error> { - Snapshot1::fd_prestat_dir_name(self, fd.into(), path, path_max_len).await + // Snapshot1::fd_prestat_dir_name(self, fd.into(), path, path_max_len).await + Snapshot1::fd_prestat_dir_name(self, fd.into(), path, path_max_len) } async fn fd_renumber(&mut self, from: types::Fd, to: types::Fd) -> Result<(), Error> { - Snapshot1::fd_renumber(self, from.into(), to.into()).await + // Snapshot1::fd_renumber(self, from.into(), to.into()).await + Snapshot1::fd_renumber(self, from.into(), to.into()) } async fn fd_seek( @@ -594,15 +609,18 @@ impl wasi_unstable::WasiUnstable for WasiCtx { offset: types::Filedelta, whence: types::Whence, ) -> Result { - Snapshot1::fd_seek(self, fd.into(), offset, whence.into()).await + // Snapshot1::fd_seek(self, fd.into(), offset, whence.into()).await + Snapshot1::fd_seek(self, fd.into(), offset, whence.into()) } - + async fn fd_sync(&mut self, fd: types::Fd) -> Result<(), Error> { - Snapshot1::fd_sync(self, fd.into()).await + // Snapshot1::fd_sync(self, fd.into()).await + Snapshot1::fd_sync(self, fd.into()) } async fn fd_tell(&mut self, fd: types::Fd) -> Result { - Snapshot1::fd_tell(self, fd.into()).await + // Snapshot1::fd_tell(self, fd.into()).await + Snapshot1::fd_tell(self, fd.into()) } async fn fd_readdir<'a>( @@ -933,7 +951,8 @@ impl wasi_unstable::WasiUnstable for WasiCtx { } async fn proc_exit(&mut self, status: types::Exitcode) -> wiggle::Trap { - Snapshot1::proc_exit(self, status).await + // Snapshot1::proc_exit(self, status).await + Snapshot1::proc_exit(self, status) } async fn proc_raise(&mut self, _sig: types::Signal) -> Result<(), Error> { @@ -949,7 +968,8 @@ impl wasi_unstable::WasiUnstable for WasiCtx { buf: &GuestPtr<'a, u8>, buf_len: types::Size, ) -> Result<(), Error> { - Snapshot1::random_get(self, buf, buf_len).await + // Snapshot1::random_get(self, buf, buf_len).await + Snapshot1::random_get(self, buf, buf_len) } async fn sock_recv<'a>( diff --git a/crates/wasi-common/src/snapshots/preview_1.rs b/crates/wasi-common/src/snapshots/preview_1.rs index 7907be103..59247d2eb 100644 --- a/crates/wasi-common/src/snapshots/preview_1.rs +++ b/crates/wasi-common/src/snapshots/preview_1.rs @@ -24,7 +24,8 @@ wiggle::from_witx!({ // Note: not every function actually needs to be async, however, nearly all of them do, and // keeping that set the same in this macro and the wasmtime_wiggle / lucet_wiggle macros is // tedious, and there is no cost to having a sync function be async in this case. - async: *, + // async: *, + async: {wasi_snapshot_preview1::fd_fdstat_get, wasi_snapshot_preview1::fd_filestat_get, wasi_snapshot_preview1::fd_filestat_set_times, wasi_snapshot_preview1::fd_readdir, wasi_snapshot_preview1::path_create_directory, wasi_snapshot_preview1::path_filestat_get, wasi_snapshot_preview1::path_filestat_set_times, wasi_snapshot_preview1::path_link, wasi_snapshot_preview1::path_open, wasi_snapshot_preview1::path_readlink, wasi_snapshot_preview1::path_remove_directory, wasi_snapshot_preview1::path_rename, wasi_snapshot_preview1::path_symlink, wasi_snapshot_preview1::path_unlink_file, wasi_snapshot_preview1::poll_oneoff, wasi_snapshot_preview1::sched_yield, wasi_snapshot_preview1::sock_accept, wasi_snapshot_preview1::sock_recv, wasi_snapshot_preview1::sock_send, wasi_snapshot_preview1::sock_shutdown}, wasmtime: false }); @@ -268,9 +269,1130 @@ impl TryFrom for types::Errno { } } +// #[wiggle::async_trait] +// impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { +// async fn args_get<'b>( +// &mut self, +// argv: &GuestPtr<'b, GuestPtr<'b, u8>>, +// argv_buf: &GuestPtr<'b, u8>, +// ) -> Result<(), Error> { +// self.args.write_to_guest(argv_buf, argv) +// } + +// async fn args_sizes_get(&mut self) -> Result<(types::Size, types::Size), Error> { +// Ok((self.args.number_elements(), self.args.cumulative_size())) +// } + +// async fn environ_get<'b>( +// &mut self, +// environ: &GuestPtr<'b, GuestPtr<'b, u8>>, +// environ_buf: &GuestPtr<'b, u8>, +// ) -> Result<(), Error> { +// self.env.write_to_guest(environ_buf, environ) +// } + +// async fn environ_sizes_get(&mut self) -> Result<(types::Size, types::Size), Error> { +// Ok((self.env.number_elements(), self.env.cumulative_size())) +// } + +// async fn clock_res_get(&mut self, id: types::Clockid) -> Result { +// let resolution = match id { +// types::Clockid::Realtime => Ok(self.clocks.system.resolution()), +// types::Clockid::Monotonic => Ok(self.clocks.monotonic.resolution()), +// types::Clockid::ProcessCputimeId | types::Clockid::ThreadCputimeId => { +// Err(Error::badf().context("process and thread clocks are not supported")) +// } +// }?; +// Ok(resolution.as_nanos().try_into()?) +// } + +// async fn clock_time_get( +// &mut self, +// id: types::Clockid, +// precision: types::Timestamp, +// ) -> Result { +// let precision = Duration::from_nanos(precision); +// match id { +// types::Clockid::Realtime => { +// let now = self.clocks.system.now(precision).into_std(); +// let d = now +// .duration_since(std::time::SystemTime::UNIX_EPOCH) +// .map_err(|_| Error::trap("current time before unix epoch"))?; +// Ok(d.as_nanos().try_into()?) +// } +// types::Clockid::Monotonic => { +// let now = self.clocks.monotonic.now(precision); +// let d = now.duration_since(self.clocks.creation_time); +// Ok(d.as_nanos().try_into()?) +// } +// types::Clockid::ProcessCputimeId | types::Clockid::ThreadCputimeId => { +// Err(Error::badf().context("process and thread clocks are not supported")) +// } +// } +// } + +// async fn fd_advise( +// &mut self, +// fd: types::Fd, +// offset: types::Filesize, +// len: types::Filesize, +// advice: types::Advice, +// ) -> Result<(), Error> { +// self.table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::ADVISE)? +// .advise(offset, len, advice.into()) +// .await?; +// Ok(()) +// } + +// async fn fd_allocate( +// &mut self, +// fd: types::Fd, +// offset: types::Filesize, +// len: types::Filesize, +// ) -> Result<(), Error> { +// self.table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::ALLOCATE)? +// .allocate(offset, len) +// .await?; +// Ok(()) +// } + +// async fn fd_close(&mut self, fd: types::Fd) -> Result<(), Error> { +// let table = self.table(); +// let fd = u32::from(fd); + +// // Fail fast: If not present in table, Badf +// if !table.contains_key(fd) { +// return Err(Error::badf().context("key not in table")); +// } +// // fd_close must close either a File or a Dir handle +// if table.is::(fd) { +// let _ = table.delete(fd); +// } else if table.is::(fd) { +// // We cannot close preopened directories +// // let dir_entry: &DirEntry = table.get(fd).unwrap(); +// // if dir_entry.preopen_path().is_some() { +// // return Err(Error::not_supported().context("cannot close propened directory")); +// // } +// // drop(dir_entry); +// let _ = table.delete(fd); +// } else { +// return Err(Error::badf().context("key does not refer to file or directory")); +// } + +// Ok(()) +// } + +// async fn fd_close_wasm64(&mut self, fd: types::Fd) -> Result<(), Error> { +// self.fd_close(fd).await +// } + +// async fn fd_datasync(&mut self, fd: types::Fd) -> Result<(), Error> { +// self.table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::DATASYNC)? +// .datasync() +// .await?; +// Ok(()) +// } + +// async fn fd_fdstat_get(&mut self, fd: types::Fd) -> Result { +// let table = self.table(); +// let fd = u32::from(fd); +// if table.is::(fd) { +// let file_entry: &mut FileEntry = table.get_mut(fd)?; +// let fdstat = file_entry.get_fdstat().await?; +// Ok(types::Fdstat::from(&fdstat)) +// } else if table.is::(fd) { +// let dir_entry: &DirEntry = table.get(fd)?; +// let dir_fdstat = dir_entry.get_dir_fdstat(); +// Ok(types::Fdstat::from(&dir_fdstat)) +// } else { +// Err(Error::badf()) +// } +// } + +// async fn fd_fdstat_get_wasm64(&mut self, _fd: types::Fd, _buf: types::Filesize) -> Result<(), Error> { +// // let stat = self.fd_fdstat_get(fd).await; +// Err(Error::badf()) +// } + +// async fn fd_fdstat_set_flags( +// &mut self, +// fd: types::Fd, +// flags: types::Fdflags, +// ) -> Result<(), Error> { +// self.table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::FDSTAT_SET_FLAGS)? +// .set_fdflags(FdFlags::from(flags)) +// .await +// } + +// async fn fd_fdstat_set_rights( +// &mut self, +// fd: types::Fd, +// fs_rights_base: types::Rights, +// fs_rights_inheriting: types::Rights, +// ) -> Result<(), Error> { +// let table = self.table(); +// let fd = u32::from(fd); +// if table.is::(fd) { +// let file_entry: &mut FileEntry = table.get_mut(fd)?; +// let file_caps = FileCaps::from(&fs_rights_base); +// file_entry.drop_caps_to(file_caps) +// } else if table.is::(fd) { +// let dir_entry: &mut DirEntry = table.get_mut(fd)?; +// let dir_caps = DirCaps::from(&fs_rights_base); +// let file_caps = FileCaps::from(&fs_rights_inheriting); +// dir_entry.drop_caps_to(dir_caps, file_caps) +// } else { +// Err(Error::badf()) +// } +// } + +// async fn fd_filestat_get(&mut self, fd: types::Fd) -> Result { +// let table = self.table(); +// let fd = u32::from(fd); +// if table.is::(fd) { +// let filestat = table +// .get_file_mut(fd)? +// .get_cap_mut(FileCaps::FILESTAT_GET)? +// .get_filestat() +// .await?; +// Ok(filestat.into()) +// } else if table.is::(fd) { +// let filestat = table +// .get_dir(fd)? +// .get_cap(DirCaps::FILESTAT_GET)? +// .get_filestat() +// .await?; +// Ok(filestat.into()) +// } else { +// Err(Error::badf()) +// } +// } + +// async fn fd_filestat_set_size( +// &mut self, +// fd: types::Fd, +// size: types::Filesize, +// ) -> Result<(), Error> { +// self.table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::FILESTAT_SET_SIZE)? +// .set_filestat_size(size) +// .await?; +// Ok(()) +// } + +// async fn fd_filestat_set_times( +// &mut self, +// fd: types::Fd, +// atim: types::Timestamp, +// mtim: types::Timestamp, +// fst_flags: types::Fstflags, +// ) -> Result<(), Error> { +// let fd = u32::from(fd); +// let table = self.table(); +// // Validate flags +// let set_atim = fst_flags.contains(types::Fstflags::ATIM); +// let set_atim_now = fst_flags.contains(types::Fstflags::ATIM_NOW); +// let set_mtim = fst_flags.contains(types::Fstflags::MTIM); +// let set_mtim_now = fst_flags.contains(types::Fstflags::MTIM_NOW); + +// let atim = systimespec(set_atim, atim, set_atim_now).context("atim")?; +// let mtim = systimespec(set_mtim, mtim, set_mtim_now).context("mtim")?; + +// if table.is::(fd) { +// table +// .get_file_mut(fd) +// .expect("checked that entry is file") +// .get_cap_mut(FileCaps::FILESTAT_SET_TIMES)? +// .set_times(atim, mtim) +// .await +// } else if table.is::(fd) { +// table +// .get_dir(fd) +// .expect("checked that entry is dir") +// .get_cap(DirCaps::FILESTAT_SET_TIMES)? +// .set_times(".", atim, mtim, false) +// .await +// } else { +// Err(Error::badf()) +// } +// } + +// async fn fd_read<'a>( +// &mut self, +// fd: types::Fd, +// iovs: &types::IovecArray<'a>, +// ) -> Result { +// let f = self +// .table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::READ)?; + +// let mut guest_slices: Vec> = iovs +// .iter() +// .map(|iov_ptr| { +// let iov_ptr = iov_ptr?; +// let iov: types::Iovec = iov_ptr.read()?; +// Ok(iov.buf.as_array(iov.buf_len).as_slice_mut()?) +// }) +// .collect::>()?; + +// let mut ioslices: Vec = guest_slices +// .iter_mut() +// .map(|s| IoSliceMut::new(&mut *s)) +// .collect(); + +// let bytes_read = f.read_vectored(&mut ioslices).await?; +// Ok(types::Size::try_from(bytes_read)?) +// } + +// async fn fd_pread<'a>( +// &mut self, +// fd: types::Fd, +// iovs: &types::IovecArray<'a>, +// offset: types::Filesize, +// ) -> Result { +// let f = self +// .table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::READ | FileCaps::SEEK)?; + +// let mut guest_slices: Vec> = iovs +// .iter() +// .map(|iov_ptr| { +// let iov_ptr = iov_ptr?; +// let iov: types::Iovec = iov_ptr.read()?; +// Ok(iov.buf.as_array(iov.buf_len).as_slice_mut()?) +// }) +// .collect::>()?; + +// let mut ioslices: Vec = guest_slices +// .iter_mut() +// .map(|s| IoSliceMut::new(&mut *s)) +// .collect(); + +// let bytes_read = f.read_vectored_at(&mut ioslices, offset).await?; +// Ok(types::Size::try_from(bytes_read)?) +// } + +// async fn fd_write<'a>( +// &mut self, +// fd: types::Fd, +// ciovs: &types::CiovecArray<'a>, +// ) -> Result { +// let f = self +// .table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::WRITE)?; + +// let guest_slices: Vec> = ciovs +// .iter() +// .map(|iov_ptr| { +// let iov_ptr = iov_ptr?; +// let iov: types::Ciovec = iov_ptr.read()?; +// Ok(iov.buf.as_array(iov.buf_len).as_slice()?) +// }) +// .collect::>()?; + +// let ioslices: Vec = guest_slices +// .iter() +// .map(|s| IoSlice::new(s.deref())) +// .collect(); +// let bytes_written = f.write_vectored(&ioslices).await?; +// Ok(types::Size::try_from(bytes_written)?) +// } + +// async fn fd_write_wasm64<'a>( +// &mut self, +// fd: types::Fd, +// ciovs: &types::LhwiovecArray<'a>, +// ) -> Result { +// let f = self +// .table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::WRITE)?; + +// let guest_slices: Vec> = ciovs +// .iter() +// .map(|iov_ptr| { +// let iov_ptr = iov_ptr?; +// let iov: types::Lhwiovec = iov_ptr.read()?; +// Ok(iov.buf.as_array(iov.buf_len.try_into().unwrap()).as_slice()?) +// }) +// .collect::>()?; + +// let ioslices: Vec = guest_slices +// .iter() +// .map(|s| IoSlice::new(s.deref())) +// .collect(); +// let bytes_written = f.write_vectored(&ioslices).await?; +// Ok(types::Filesize::try_from(bytes_written)?) +// } + +// async fn fd_pwrite<'a>( +// &mut self, +// fd: types::Fd, +// ciovs: &types::CiovecArray<'a>, +// offset: types::Filesize, +// ) -> Result { +// let f = self +// .table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::WRITE | FileCaps::SEEK)?; + +// let guest_slices: Vec> = ciovs +// .iter() +// .map(|iov_ptr| { +// let iov_ptr = iov_ptr?; +// let iov: types::Ciovec = iov_ptr.read()?; +// Ok(iov.buf.as_array(iov.buf_len).as_slice()?) +// }) +// .collect::>()?; + +// let ioslices: Vec = guest_slices +// .iter() +// .map(|s| IoSlice::new(s.deref())) +// .collect(); +// let bytes_written = f.write_vectored_at(&ioslices, offset).await?; + +// Ok(types::Size::try_from(bytes_written)?) +// } + +// async fn fd_prestat_get(&mut self, fd: types::Fd) -> Result { +// let table = self.table(); +// let dir_entry: &DirEntry = table.get(u32::from(fd)).map_err(|_| Error::badf())?; +// if let Some(ref preopen) = dir_entry.preopen_path() { +// let path_str = preopen.to_str().ok_or_else(|| Error::not_supported())?; +// let pr_name_len = u32::try_from(path_str.as_bytes().len())?; +// Ok(types::Prestat::Dir(types::PrestatDir { pr_name_len })) +// } else { +// Err(Error::not_supported().context("file is not a preopen")) +// } +// } + +// async fn fd_prestat_dir_name<'a>( +// &mut self, +// fd: types::Fd, +// path: &GuestPtr<'a, u8>, +// path_max_len: types::Size, +// ) -> Result<(), Error> { +// let table = self.table(); +// let dir_entry: &DirEntry = table.get(u32::from(fd)).map_err(|_| Error::not_dir())?; +// if let Some(ref preopen) = dir_entry.preopen_path() { +// let path_bytes = preopen +// .to_str() +// .ok_or_else(|| Error::not_supported())? +// .as_bytes(); +// let path_len = path_bytes.len(); +// if path_len < path_max_len as usize { +// return Err(Error::name_too_long()); +// } +// let mut p_memory = path.as_array(path_len as u32).as_slice_mut()?; +// p_memory.copy_from_slice(path_bytes); +// Ok(()) +// } else { +// Err(Error::not_supported()) +// } +// } +// async fn fd_renumber(&mut self, from: types::Fd, to: types::Fd) -> Result<(), Error> { +// let table = self.table(); +// let from = u32::from(from); +// let to = u32::from(to); +// if !table.contains_key(from) { +// return Err(Error::badf()); +// } +// if table.is_preopen(from) || table.is_preopen(to) { +// return Err(Error::not_supported().context("cannot renumber a preopen")); +// } +// let from_entry = table +// .delete(from) +// .expect("we checked that table contains from"); +// table.insert_at(to, from_entry); +// Ok(()) +// } + +// async fn fd_seek( +// &mut self, +// fd: types::Fd, +// offset: types::Filedelta, +// whence: types::Whence, +// ) -> Result { +// use std::io::SeekFrom; + +// let required_caps = if offset == 0 && whence == types::Whence::Cur { +// FileCaps::TELL +// } else { +// FileCaps::TELL | FileCaps::SEEK +// }; + +// let whence = match whence { +// types::Whence::Cur => SeekFrom::Current(offset), +// types::Whence::End => SeekFrom::End(offset), +// types::Whence::Set => SeekFrom::Start(offset as u64), +// }; +// let newoffset = self +// .table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(required_caps)? +// .seek(whence) +// .await?; +// Ok(newoffset) +// } + +// async fn fd_seek_wasm64( +// &mut self, +// _fd: types::Fd, +// _offset: types::Filedelta, +// _whence: types::Whence, +// _newoffset: types::Filesize, +// ) -> Result<(), Error> { +// // self.fd_seek(fd, offset, whence).await +// unimplemented!("fd_seek_wasm64") +// } + +// async fn fd_sync(&mut self, fd: types::Fd) -> Result<(), Error> { +// self.table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::SYNC)? +// .sync() +// .await?; +// Ok(()) +// } + +// async fn fd_tell(&mut self, fd: types::Fd) -> Result { +// // XXX should this be stream_position? +// let offset = self +// .table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::TELL)? +// .seek(std::io::SeekFrom::Current(0)) +// .await?; +// Ok(offset) +// } + +// async fn fd_readdir<'a>( +// &mut self, +// fd: types::Fd, +// buf: &GuestPtr<'a, u8>, +// buf_len: types::Size, +// cookie: types::Dircookie, +// ) -> Result { +// let mut bufused = 0; +// let mut buf = buf.clone(); +// for entity in self +// .table() +// .get_dir(u32::from(fd))? +// .get_cap(DirCaps::READDIR)? +// .readdir(ReaddirCursor::from(cookie)) +// .await? +// { +// let entity = entity?; +// let dirent_raw = dirent_bytes(types::Dirent::try_from(&entity)?); +// let dirent_len: types::Size = dirent_raw.len().try_into()?; +// let name_raw = entity.name.as_bytes(); +// let name_len: types::Size = name_raw.len().try_into()?; + +// // Copy as many bytes of the dirent as we can, up to the end of the buffer +// let dirent_copy_len = std::cmp::min(dirent_len, buf_len - bufused); +// buf.as_array(dirent_copy_len) +// .copy_from_slice(&dirent_raw[..dirent_copy_len as usize])?; + +// // If the dirent struct wasnt compied entirely, return that we filled the buffer, which +// // tells libc that we're not at EOF. +// if dirent_copy_len < dirent_len { +// return Ok(buf_len); +// } + +// buf = buf.add(dirent_copy_len)?; +// bufused += dirent_copy_len; + +// // Copy as many bytes of the name as we can, up to the end of the buffer +// let name_copy_len = std::cmp::min(name_len, buf_len - bufused); +// buf.as_array(name_copy_len) +// .copy_from_slice(&name_raw[..name_copy_len as usize])?; + +// // If the dirent struct wasn't copied entirely, return that we filled the buffer, which +// // tells libc that we're not at EOF + +// if name_copy_len < name_len { +// return Ok(buf_len); +// } + +// buf = buf.add(name_copy_len)?; +// bufused += name_copy_len; +// } +// Ok(bufused) +// } + +// async fn path_create_directory<'a>( +// &mut self, +// dirfd: types::Fd, +// path: &GuestPtr<'a, str>, +// ) -> Result<(), Error> { +// self.table() +// .get_dir(u32::from(dirfd))? +// .get_cap(DirCaps::CREATE_DIRECTORY)? +// .create_dir(path.as_str()?.deref()) +// .await +// } + +// async fn path_filestat_get<'a>( +// &mut self, +// dirfd: types::Fd, +// flags: types::Lookupflags, +// path: &GuestPtr<'a, str>, +// ) -> Result { +// let filestat = self +// .table() +// .get_dir(u32::from(dirfd))? +// .get_cap(DirCaps::PATH_FILESTAT_GET)? +// .get_path_filestat( +// path.as_str()?.deref(), +// flags.contains(types::Lookupflags::SYMLINK_FOLLOW), +// ) +// .await?; +// Ok(types::Filestat::from(filestat)) +// } + +// async fn path_filestat_set_times<'a>( +// &mut self, +// dirfd: types::Fd, +// flags: types::Lookupflags, +// path: &GuestPtr<'a, str>, +// atim: types::Timestamp, +// mtim: types::Timestamp, +// fst_flags: types::Fstflags, +// ) -> Result<(), Error> { +// let set_atim = fst_flags.contains(types::Fstflags::ATIM); +// let set_atim_now = fst_flags.contains(types::Fstflags::ATIM_NOW); +// let set_mtim = fst_flags.contains(types::Fstflags::MTIM); +// let set_mtim_now = fst_flags.contains(types::Fstflags::MTIM_NOW); + +// let atim = systimespec(set_atim, atim, set_atim_now).context("atim")?; +// let mtim = systimespec(set_mtim, mtim, set_mtim_now).context("mtim")?; +// self.table() +// .get_dir(u32::from(dirfd))? +// .get_cap(DirCaps::PATH_FILESTAT_SET_TIMES)? +// .set_times( +// path.as_str()?.deref(), +// atim, +// mtim, +// flags.contains(types::Lookupflags::SYMLINK_FOLLOW), +// ) +// .await +// } + +// async fn path_link<'a>( +// &mut self, +// src_fd: types::Fd, +// src_flags: types::Lookupflags, +// src_path: &GuestPtr<'a, str>, +// target_fd: types::Fd, +// target_path: &GuestPtr<'a, str>, +// ) -> Result<(), Error> { +// let table = self.table(); +// let src_dir = table +// .get_dir(u32::from(src_fd))? +// .get_cap(DirCaps::LINK_SOURCE)?; +// let target_dir = table +// .get_dir(u32::from(target_fd))? +// .get_cap(DirCaps::LINK_TARGET)?; +// let symlink_follow = src_flags.contains(types::Lookupflags::SYMLINK_FOLLOW); +// if symlink_follow { +// return Err(Error::invalid_argument() +// .context("symlink following on path_link is not supported")); +// } + +// src_dir +// .hard_link( +// src_path.as_str()?.deref(), +// target_dir.deref(), +// target_path.as_str()?.deref(), +// ) +// .await +// } + +// async fn path_open<'a>( +// &mut self, +// dirfd: types::Fd, +// dirflags: types::Lookupflags, +// path: &GuestPtr<'a, str>, +// oflags: types::Oflags, +// fs_rights_base: types::Rights, +// fs_rights_inheriting: types::Rights, +// fdflags: types::Fdflags, +// ) -> Result { +// let table = self.table(); +// let dirfd = u32::from(dirfd); +// if table.is::(dirfd) { +// return Err(Error::not_dir()); +// } +// let dir_entry = table.get_dir(dirfd)?; + +// let symlink_follow = dirflags.contains(types::Lookupflags::SYMLINK_FOLLOW); + +// let oflags = OFlags::from(&oflags); +// let fdflags = FdFlags::from(fdflags); +// let path = path.as_str()?; +// if oflags.contains(OFlags::DIRECTORY) { +// if oflags.contains(OFlags::CREATE) +// || oflags.contains(OFlags::EXCLUSIVE) +// || oflags.contains(OFlags::TRUNCATE) +// { +// return Err(Error::invalid_argument().context("directory oflags")); +// } +// let dir_caps = dir_entry.child_dir_caps(DirCaps::from(&fs_rights_base)); +// let file_caps = dir_entry.child_file_caps(FileCaps::from(&fs_rights_inheriting)); +// let dir = dir_entry.get_cap(DirCaps::OPEN)?; +// let child_dir = dir.open_dir(symlink_follow, path.deref()).await?; +// // drop(dir); +// let fd = table.push(Box::new(DirEntry::new( +// dir_caps, file_caps, None, child_dir, +// )))?; +// Ok(types::Fd::from(fd)) +// } else { +// let mut required_caps = DirCaps::OPEN; +// if oflags.contains(OFlags::CREATE) { +// required_caps = required_caps | DirCaps::CREATE_FILE; +// } + +// let file_caps = dir_entry.child_file_caps(FileCaps::from(&fs_rights_base)); +// let dir = dir_entry.get_cap(required_caps)?; +// let read = file_caps.contains(FileCaps::READ); +// let write = file_caps.contains(FileCaps::WRITE) +// || file_caps.contains(FileCaps::ALLOCATE) +// || file_caps.contains(FileCaps::FILESTAT_SET_SIZE); +// let file = dir +// .open_file(symlink_follow, path.deref(), oflags, read, write, fdflags) +// .await?; +// // drop(dir); +// let fd = table.push(Box::new(FileEntry::new(file_caps, file)))?; +// Ok(types::Fd::from(fd)) +// } +// } + +// async fn path_readlink<'a>( +// &mut self, +// dirfd: types::Fd, +// path: &GuestPtr<'a, str>, +// buf: &GuestPtr<'a, u8>, +// buf_len: types::Size, +// ) -> Result { +// let link = self +// .table() +// .get_dir(u32::from(dirfd))? +// .get_cap(DirCaps::READLINK)? +// .read_link(path.as_str()?.deref()) +// .await? +// .into_os_string() +// .into_string() +// .map_err(|_| Error::illegal_byte_sequence().context("link contents"))?; +// let link_bytes = link.as_bytes(); +// let link_len = link_bytes.len(); +// if link_len > buf_len as usize { +// return Err(Error::range()); +// } +// let mut buf = buf.as_array(link_len as u32).as_slice_mut()?; +// buf.copy_from_slice(link_bytes); +// Ok(link_len as types::Size) +// } + +// async fn path_remove_directory<'a>( +// &mut self, +// dirfd: types::Fd, +// path: &GuestPtr<'a, str>, +// ) -> Result<(), Error> { +// self.table() +// .get_dir(u32::from(dirfd))? +// .get_cap(DirCaps::REMOVE_DIRECTORY)? +// .remove_dir(path.as_str()?.deref()) +// .await +// } + +// async fn path_rename<'a>( +// &mut self, +// src_fd: types::Fd, +// src_path: &GuestPtr<'a, str>, +// dest_fd: types::Fd, +// dest_path: &GuestPtr<'a, str>, +// ) -> Result<(), Error> { +// let table = self.table(); +// let src_dir = table +// .get_dir(u32::from(src_fd))? +// .get_cap(DirCaps::RENAME_SOURCE)?; +// let dest_dir = table +// .get_dir(u32::from(dest_fd))? +// .get_cap(DirCaps::RENAME_TARGET)?; +// src_dir +// .rename( +// src_path.as_str()?.deref(), +// dest_dir.deref(), +// dest_path.as_str()?.deref(), +// ) +// .await +// } + +// async fn path_symlink<'a>( +// &mut self, +// src_path: &GuestPtr<'a, str>, +// dirfd: types::Fd, +// dest_path: &GuestPtr<'a, str>, +// ) -> Result<(), Error> { +// self.table() +// .get_dir(u32::from(dirfd))? +// .get_cap(DirCaps::SYMLINK)? +// .symlink(src_path.as_str()?.deref(), dest_path.as_str()?.deref()) +// .await +// } + +// async fn path_unlink_file<'a>( +// &mut self, +// dirfd: types::Fd, +// path: &GuestPtr<'a, str>, +// ) -> Result<(), Error> { +// self.table() +// .get_dir(u32::from(dirfd))? +// .get_cap(DirCaps::UNLINK_FILE)? +// .unlink_file(path.as_str()?.deref()) +// .await +// } + +// async fn poll_oneoff<'a>( +// &mut self, +// subs: &GuestPtr<'a, types::Subscription>, +// events: &GuestPtr<'a, types::Event>, +// nsubscriptions: types::Size, +// ) -> Result { +// if nsubscriptions == 0 { +// return Err(Error::invalid_argument().context("nsubscriptions must be nonzero")); +// } + +// // Special-case a `poll_oneoff` which is just sleeping on a single +// // relative timer event, such as what WASI libc uses to implement sleep +// // functions. This supports all clock IDs, because POSIX says that +// // `clock_settime` doesn't effect relative sleeps. +// if nsubscriptions == 1 { +// let sub = subs.read()?; +// if let types::SubscriptionU::Clock(clocksub) = sub.u { +// if !clocksub +// .flags +// .contains(types::Subclockflags::SUBSCRIPTION_CLOCK_ABSTIME) +// { +// self.sched +// .sleep(Duration::from_nanos(clocksub.timeout)) +// .await?; +// events.write(types::Event { +// userdata: sub.userdata, +// error: types::Errno::Success, +// type_: types::Eventtype::Clock, +// fd_readwrite: fd_readwrite_empty(), +// })?; +// return Ok(1); +// } +// } +// } + +// let table = &mut self.table; +// // We need these refmuts to outlive Poll, which will hold the &mut dyn WasiFile inside +// let mut read_refs: Vec<(&dyn WasiFile, Userdata)> = Vec::new(); +// let mut write_refs: Vec<(&dyn WasiFile, Userdata)> = Vec::new(); +// let mut poll = Poll::new(); + +// let subs = subs.as_array(nsubscriptions); +// for sub_elem in subs.iter() { +// let sub_ptr = sub_elem?; +// let sub = sub_ptr.read()?; +// match sub.u { +// types::SubscriptionU::Clock(clocksub) => match clocksub.id { +// types::Clockid::Monotonic => { +// let clock = self.clocks.monotonic.deref(); +// let precision = Duration::from_nanos(clocksub.precision); +// let duration = Duration::from_nanos(clocksub.timeout); +// let deadline = if clocksub +// .flags +// .contains(types::Subclockflags::SUBSCRIPTION_CLOCK_ABSTIME) +// { +// self.clocks +// .creation_time +// .checked_add(duration) +// .ok_or_else(|| Error::overflow().context("deadline"))? +// } else { +// clock +// .now(precision) +// .checked_add(duration) +// .ok_or_else(|| Error::overflow().context("deadline"))? +// }; +// poll.subscribe_monotonic_clock( +// clock, +// deadline, +// precision, +// sub.userdata.into(), +// ) +// } +// types::Clockid::Realtime => { +// // POSIX specifies that functions like `nanosleep` and others use the +// // `REALTIME` clock. But it also says that `clock_settime` has no effect +// // on threads waiting in these functions. MONOTONIC should always have +// // resolution at least as good as REALTIME, so we can translate a +// // non-absolute `REALTIME` request into a `MONOTONIC` request. +// let clock = self.clocks.monotonic.deref(); +// let precision = Duration::from_nanos(clocksub.precision); +// let duration = Duration::from_nanos(clocksub.timeout); +// let deadline = if clocksub +// .flags +// .contains(types::Subclockflags::SUBSCRIPTION_CLOCK_ABSTIME) +// { +// return Err(Error::not_supported()); +// } else { +// clock +// .now(precision) +// .checked_add(duration) +// .ok_or_else(|| Error::overflow().context("deadline"))? +// }; +// poll.subscribe_monotonic_clock( +// clock, +// deadline, +// precision, +// sub.userdata.into(), +// ) +// } +// _ => Err(Error::invalid_argument() +// .context("timer subscriptions only support monotonic timer"))?, +// }, +// types::SubscriptionU::FdRead(readsub) => { +// let fd = readsub.file_descriptor; +// let file_ref = table +// .get_file(u32::from(fd))? +// .get_cap(FileCaps::POLL_READWRITE)?; +// read_refs.push((file_ref, sub.userdata.into())); +// } +// types::SubscriptionU::FdWrite(writesub) => { +// let fd = writesub.file_descriptor; +// let file_ref = table +// .get_file(u32::from(fd))? +// .get_cap(FileCaps::POLL_READWRITE)?; +// write_refs.push((file_ref, sub.userdata.into())); +// } +// } +// } + +// for (f, ud) in read_refs.iter_mut() { +// poll.subscribe_read(*f, *ud); +// } +// for (f, ud) in write_refs.iter_mut() { +// poll.subscribe_write(*f, *ud); +// } + +// self.sched.poll_oneoff(&mut poll).await?; + +// let results = poll.results(); +// let num_results = results.len(); +// assert!( +// num_results <= nsubscriptions as usize, +// "results exceeds subscriptions" +// ); +// let events = events.as_array( +// num_results +// .try_into() +// .expect("not greater than nsubscriptions"), +// ); +// for ((result, userdata), event_elem) in results.into_iter().zip(events.iter()) { +// let event_ptr = event_elem?; +// let userdata: types::Userdata = userdata.into(); +// event_ptr.write(match result { +// SubscriptionResult::Read(r) => { +// let type_ = types::Eventtype::FdRead; +// match r { +// Ok((nbytes, flags)) => types::Event { +// userdata, +// error: types::Errno::Success, +// type_, +// fd_readwrite: types::EventFdReadwrite { +// nbytes, +// flags: types::Eventrwflags::from(&flags), +// }, +// }, +// Err(e) => types::Event { +// userdata, +// error: e.try_into().expect("non-trapping"), +// type_, +// fd_readwrite: fd_readwrite_empty(), +// }, +// } +// } +// SubscriptionResult::Write(r) => { +// let type_ = types::Eventtype::FdWrite; +// match r { +// Ok((nbytes, flags)) => types::Event { +// userdata, +// error: types::Errno::Success, +// type_, +// fd_readwrite: types::EventFdReadwrite { +// nbytes, +// flags: types::Eventrwflags::from(&flags), +// }, +// }, +// Err(e) => types::Event { +// userdata, +// error: e.try_into()?, +// type_, +// fd_readwrite: fd_readwrite_empty(), +// }, +// } +// } +// SubscriptionResult::MonotonicClock(r) => { +// let type_ = types::Eventtype::Clock; +// types::Event { +// userdata, +// error: match r { +// Ok(()) => types::Errno::Success, +// Err(e) => e.try_into()?, +// }, +// type_, +// fd_readwrite: fd_readwrite_empty(), +// } +// } +// })?; +// } + +// Ok(num_results.try_into().expect("results fit into memory")) +// } + +// async fn proc_exit(&mut self, status: types::Exitcode) -> wiggle::Trap { +// // Check that the status is within WASI's range. +// if status < 126 { +// wiggle::Trap::I32Exit(status as i32) +// } else { +// wiggle::Trap::String("exit with invalid exit status outside of [0..126)".to_owned()) +// } +// } + +// async fn proc_exit_wasm64(&mut self, status: types::Exitcode) -> wiggle::Trap { +// self.proc_exit(status).await +// } + +// async fn proc_raise(&mut self, _sig: types::Signal) -> Result<(), Error> { +// Err(Error::trap("proc_raise unsupported")) +// } + +// async fn sched_yield(&mut self) -> Result<(), Error> { +// self.sched.sched_yield().await +// } + +// async fn random_get<'a>( +// &mut self, +// buf: &GuestPtr<'a, u8>, +// buf_len: types::Size, +// ) -> Result<(), Error> { +// let mut buf = buf.as_array(buf_len).as_slice_mut()?; +// if buf_len == 12 { +// buf.new_wasi_func(); +// } else { +// self.random.try_fill_bytes(buf.deref_mut())?; +// } +// Ok(()) +// } + +// async fn sock_accept( +// &mut self, +// fd: types::Fd, +// flags: types::Fdflags, +// ) -> Result { +// let table = self.table(); +// let f = table +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::READ)?; + +// let file = f.sock_accept(FdFlags::from(flags)).await?; +// let file_caps = FileCaps::READ +// | FileCaps::WRITE +// | FileCaps::FDSTAT_SET_FLAGS +// | FileCaps::POLL_READWRITE +// | FileCaps::FILESTAT_GET; + +// let fd = table.push(Box::new(FileEntry::new(file_caps, file)))?; +// Ok(types::Fd::from(fd)) +// } + +// async fn sock_recv<'a>( +// &mut self, +// fd: types::Fd, +// ri_data: &types::IovecArray<'a>, +// ri_flags: types::Riflags, +// ) -> Result<(types::Size, types::Roflags), Error> { +// let f = self +// .table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::READ)?; + +// let mut guest_slices: Vec> = ri_data +// .iter() +// .map(|iov_ptr| { +// let iov_ptr = iov_ptr?; +// let iov: types::Iovec = iov_ptr.read()?; +// Ok(iov.buf.as_array(iov.buf_len).as_slice_mut()?) +// }) +// .collect::>()?; + +// let mut ioslices: Vec = guest_slices +// .iter_mut() +// .map(|s| IoSliceMut::new(&mut *s)) +// .collect(); + +// let (bytes_read, roflags) = f.sock_recv(&mut ioslices, RiFlags::from(ri_flags)).await?; +// Ok((types::Size::try_from(bytes_read)?, roflags.into())) +// } + +// async fn sock_send<'a>( +// &mut self, +// fd: types::Fd, +// si_data: &types::CiovecArray<'a>, +// _si_flags: types::Siflags, +// ) -> Result { +// let f = self +// .table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::WRITE)?; + +// let guest_slices: Vec> = si_data +// .iter() +// .map(|iov_ptr| { +// let iov_ptr = iov_ptr?; +// let iov: types::Ciovec = iov_ptr.read()?; +// Ok(iov.buf.as_array(iov.buf_len).as_slice()?) +// }) +// .collect::>()?; + +// let ioslices: Vec = guest_slices +// .iter() +// .map(|s| IoSlice::new(s.deref())) +// .collect(); +// let bytes_written = f.sock_send(&ioslices, SiFlags::empty()).await?; + +// Ok(types::Size::try_from(bytes_written)?) +// } + +// async fn sock_shutdown(&mut self, fd: types::Fd, how: types::Sdflags) -> Result<(), Error> { +// let f = self +// .table() +// .get_file_mut(u32::from(fd))? +// .get_cap_mut(FileCaps::FDSTAT_SET_FLAGS)?; + +// f.sock_shutdown(SdFlags::from(how)).await +// } +// } + #[wiggle::async_trait] impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { - async fn args_get<'b>( + fn args_get<'b>( &mut self, argv: &GuestPtr<'b, GuestPtr<'b, u8>>, argv_buf: &GuestPtr<'b, u8>, @@ -278,11 +1400,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { self.args.write_to_guest(argv_buf, argv) } - async fn args_sizes_get(&mut self) -> Result<(types::Size, types::Size), Error> { + fn args_sizes_get(&mut self) -> Result<(types::Size, types::Size), Error> { Ok((self.args.number_elements(), self.args.cumulative_size())) } - async fn environ_get<'b>( + fn environ_get<'b>( &mut self, environ: &GuestPtr<'b, GuestPtr<'b, u8>>, environ_buf: &GuestPtr<'b, u8>, @@ -290,11 +1412,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { self.env.write_to_guest(environ_buf, environ) } - async fn environ_sizes_get(&mut self) -> Result<(types::Size, types::Size), Error> { + fn environ_sizes_get(&mut self) -> Result<(types::Size, types::Size), Error> { Ok((self.env.number_elements(), self.env.cumulative_size())) } - async fn clock_res_get(&mut self, id: types::Clockid) -> Result { + fn clock_res_get(&mut self, id: types::Clockid) -> Result { let resolution = match id { types::Clockid::Realtime => Ok(self.clocks.system.resolution()), types::Clockid::Monotonic => Ok(self.clocks.monotonic.resolution()), @@ -305,7 +1427,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { Ok(resolution.as_nanos().try_into()?) } - async fn clock_time_get( + fn clock_time_get( &mut self, id: types::Clockid, precision: types::Timestamp, @@ -330,7 +1452,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { } } - async fn fd_advise( + fn fd_advise( &mut self, fd: types::Fd, offset: types::Filesize, @@ -340,12 +1462,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { self.table() .get_file_mut(u32::from(fd))? .get_cap_mut(FileCaps::ADVISE)? - .advise(offset, len, advice.into()) - .await?; + .advise_sync(offset, len, advice.into())?; Ok(()) } - async fn fd_allocate( + fn fd_allocate( &mut self, fd: types::Fd, offset: types::Filesize, @@ -354,12 +1475,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { self.table() .get_file_mut(u32::from(fd))? .get_cap_mut(FileCaps::ALLOCATE)? - .allocate(offset, len) - .await?; + .allocate_sync(offset, len)?; Ok(()) } - async fn fd_close(&mut self, fd: types::Fd) -> Result<(), Error> { + fn fd_close(&mut self, fd: types::Fd) -> Result<(), Error> { let table = self.table(); let fd = u32::from(fd); @@ -372,11 +1492,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { let _ = table.delete(fd); } else if table.is::(fd) { // We cannot close preopened directories - let dir_entry: &DirEntry = table.get(fd).unwrap(); - if dir_entry.preopen_path().is_some() { - return Err(Error::not_supported().context("cannot close propened directory")); - } - drop(dir_entry); + // let dir_entry: &DirEntry = table.get(fd).unwrap(); + // if dir_entry.preopen_path().is_some() { + // return Err(Error::not_supported().context("cannot close propened directory")); + // } + // drop(dir_entry); let _ = table.delete(fd); } else { return Err(Error::badf().context("key does not refer to file or directory")); @@ -385,12 +1505,15 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { Ok(()) } - async fn fd_datasync(&mut self, fd: types::Fd) -> Result<(), Error> { + fn fd_close_wasm64(&mut self, fd: types::Fd) -> Result<(), Error> { + self.fd_close(fd) + } + + fn fd_datasync(&mut self, fd: types::Fd) -> Result<(), Error> { self.table() .get_file_mut(u32::from(fd))? .get_cap_mut(FileCaps::DATASYNC)? - .datasync() - .await?; + .datasync_sync()?; Ok(()) } @@ -410,7 +1533,12 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { } } - async fn fd_fdstat_set_flags( + fn fd_fdstat_get_wasm64(&mut self, _fd: types::Fd, _buf: types::Filesize) -> Result<(), Error> { + // let stat = self.fd_fdstat_get(fd).await; + Err(Error::badf()) + } + + fn fd_fdstat_set_flags( &mut self, fd: types::Fd, flags: types::Fdflags, @@ -418,11 +1546,10 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { self.table() .get_file_mut(u32::from(fd))? .get_cap_mut(FileCaps::FDSTAT_SET_FLAGS)? - .set_fdflags(FdFlags::from(flags)) - .await + .set_fdflags_sync(FdFlags::from(flags)) } - async fn fd_fdstat_set_rights( + fn fd_fdstat_set_rights( &mut self, fd: types::Fd, fs_rights_base: types::Rights, @@ -466,7 +1593,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { } } - async fn fd_filestat_set_size( + fn fd_filestat_set_size( &mut self, fd: types::Fd, size: types::Filesize, @@ -474,8 +1601,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { self.table() .get_file_mut(u32::from(fd))? .get_cap_mut(FileCaps::FILESTAT_SET_SIZE)? - .set_filestat_size(size) - .await?; + .set_filestat_size_sync(size)?; Ok(()) } @@ -516,7 +1642,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { } } - async fn fd_read<'a>( + fn fd_read<'a>( &mut self, fd: types::Fd, iovs: &types::IovecArray<'a>, @@ -540,11 +1666,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { .map(|s| IoSliceMut::new(&mut *s)) .collect(); - let bytes_read = f.read_vectored(&mut ioslices).await?; + let bytes_read = f.read_vectored_sync(&mut ioslices)?; Ok(types::Size::try_from(bytes_read)?) } - async fn fd_pread<'a>( + fn fd_pread<'a>( &mut self, fd: types::Fd, iovs: &types::IovecArray<'a>, @@ -569,11 +1695,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { .map(|s| IoSliceMut::new(&mut *s)) .collect(); - let bytes_read = f.read_vectored_at(&mut ioslices, offset).await?; + let bytes_read = f.read_vectored_at_sync(&mut ioslices, offset)?; Ok(types::Size::try_from(bytes_read)?) } - async fn fd_write<'a>( + fn fd_write<'a>( &mut self, fd: types::Fd, ciovs: &types::CiovecArray<'a>, @@ -596,12 +1722,38 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { .iter() .map(|s| IoSlice::new(s.deref())) .collect(); - let bytes_written = f.write_vectored(&ioslices).await?; - + let bytes_written = f.write_vectored_sync(&ioslices)?; Ok(types::Size::try_from(bytes_written)?) } - async fn fd_pwrite<'a>( + fn fd_write_wasm64<'a>( + &mut self, + fd: types::Fd, + ciovs: &types::LhwiovecArray<'a>, + ) -> Result { + let f = self + .table() + .get_file_mut(u32::from(fd))? + .get_cap_mut(FileCaps::WRITE)?; + + let guest_slices: Vec> = ciovs + .iter() + .map(|iov_ptr| { + let iov_ptr = iov_ptr?; + let iov: types::Lhwiovec = iov_ptr.read()?; + Ok(iov.buf.as_array(iov.buf_len.try_into().unwrap()).as_slice()?) + }) + .collect::>()?; + + let ioslices: Vec = guest_slices + .iter() + .map(|s| IoSlice::new(s.deref())) + .collect(); + let bytes_written = f.write_vectored_sync(&ioslices)?; + Ok(types::Filesize::try_from(bytes_written)?) + } + + fn fd_pwrite<'a>( &mut self, fd: types::Fd, ciovs: &types::CiovecArray<'a>, @@ -625,12 +1777,12 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { .iter() .map(|s| IoSlice::new(s.deref())) .collect(); - let bytes_written = f.write_vectored_at(&ioslices, offset).await?; + let bytes_written = f.write_vectored_at_sync(&ioslices, offset)?; Ok(types::Size::try_from(bytes_written)?) } - async fn fd_prestat_get(&mut self, fd: types::Fd) -> Result { + fn fd_prestat_get(&mut self, fd: types::Fd) -> Result { let table = self.table(); let dir_entry: &DirEntry = table.get(u32::from(fd)).map_err(|_| Error::badf())?; if let Some(ref preopen) = dir_entry.preopen_path() { @@ -642,7 +1794,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { } } - async fn fd_prestat_dir_name<'a>( + fn fd_prestat_dir_name<'a>( &mut self, fd: types::Fd, path: &GuestPtr<'a, u8>, @@ -666,7 +1818,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { Err(Error::not_supported()) } } - async fn fd_renumber(&mut self, from: types::Fd, to: types::Fd) -> Result<(), Error> { + fn fd_renumber(&mut self, from: types::Fd, to: types::Fd) -> Result<(), Error> { let table = self.table(); let from = u32::from(from); let to = u32::from(to); @@ -683,7 +1835,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { Ok(()) } - async fn fd_seek( + fn fd_seek( &mut self, fd: types::Fd, offset: types::Filedelta, @@ -706,28 +1858,36 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { .table() .get_file_mut(u32::from(fd))? .get_cap_mut(required_caps)? - .seek(whence) - .await?; + .seek_sync(whence)?; Ok(newoffset) } - async fn fd_sync(&mut self, fd: types::Fd) -> Result<(), Error> { + fn fd_seek_wasm64( + &mut self, + _fd: types::Fd, + _offset: types::Filedelta, + _whence: types::Whence, + _newoffset: types::Filesize, + ) -> Result<(), Error> { + // self.fd_seek(fd, offset, whence).await + unimplemented!("fd_seek_wasm64") + } + + fn fd_sync(&mut self, fd: types::Fd) -> Result<(), Error> { self.table() .get_file_mut(u32::from(fd))? .get_cap_mut(FileCaps::SYNC)? - .sync() - .await?; + .sync_sync()?; Ok(()) } - async fn fd_tell(&mut self, fd: types::Fd) -> Result { + fn fd_tell(&mut self, fd: types::Fd) -> Result { // XXX should this be stream_position? let offset = self .table() .get_file_mut(u32::from(fd))? .get_cap_mut(FileCaps::TELL)? - .seek(std::io::SeekFrom::Current(0)) - .await?; + .seek_sync(std::io::SeekFrom::Current(0))?; Ok(offset) } @@ -906,7 +2066,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { let file_caps = dir_entry.child_file_caps(FileCaps::from(&fs_rights_inheriting)); let dir = dir_entry.get_cap(DirCaps::OPEN)?; let child_dir = dir.open_dir(symlink_follow, path.deref()).await?; - drop(dir); + // drop(dir); let fd = table.push(Box::new(DirEntry::new( dir_caps, file_caps, None, child_dir, )))?; @@ -926,7 +2086,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { let file = dir .open_file(symlink_follow, path.deref(), oflags, read, write, fdflags) .await?; - drop(dir); + // drop(dir); let fd = table.push(Box::new(FileEntry::new(file_caps, file)))?; Ok(types::Fd::from(fd)) } @@ -1219,7 +2379,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { Ok(num_results.try_into().expect("results fit into memory")) } - async fn proc_exit(&mut self, status: types::Exitcode) -> wiggle::Trap { + fn proc_exit(&mut self, status: types::Exitcode) -> wiggle::Trap { // Check that the status is within WASI's range. if status < 126 { wiggle::Trap::I32Exit(status as i32) @@ -1228,7 +2388,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { } } - async fn proc_raise(&mut self, _sig: types::Signal) -> Result<(), Error> { + fn proc_exit_wasm64(&mut self, status: types::Exitcode) -> wiggle::Trap { + self.proc_exit(status) + } + + fn proc_raise(&mut self, _sig: types::Signal) -> Result<(), Error> { Err(Error::trap("proc_raise unsupported")) } @@ -1236,13 +2400,17 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx { self.sched.sched_yield().await } - async fn random_get<'a>( + fn random_get<'a>( &mut self, buf: &GuestPtr<'a, u8>, buf_len: types::Size, ) -> Result<(), Error> { let mut buf = buf.as_array(buf_len).as_slice_mut()?; - self.random.try_fill_bytes(buf.deref_mut())?; + if buf_len == 12 { + buf.new_wasi_func(); + } else { + self.random.try_fill_bytes(buf.deref_mut())?; + } Ok(()) } diff --git a/crates/wasi/src/lib.rs b/crates/wasi/src/lib.rs index 177442397..497450334 100644 --- a/crates/wasi/src/lib.rs +++ b/crates/wasi/src/lib.rs @@ -67,7 +67,8 @@ pub mod snapshots { // the `WASI_ROOT` env variable, which is set in wasi-common's `build.rs`. witx: ["$WASI_ROOT/phases/snapshot/witx/wasi_snapshot_preview1.witx"], errors: { errno => Error }, - $async_mode: * + // $async_mode: * + $async_mode: {wasi_snapshot_preview1::fd_fdstat_get, wasi_snapshot_preview1::fd_filestat_get, wasi_snapshot_preview1::fd_filestat_set_times, wasi_snapshot_preview1::fd_readdir, wasi_snapshot_preview1::path_create_directory, wasi_snapshot_preview1::path_filestat_get, wasi_snapshot_preview1::path_filestat_set_times, wasi_snapshot_preview1::path_link, wasi_snapshot_preview1::path_open, wasi_snapshot_preview1::path_readlink, wasi_snapshot_preview1::path_remove_directory, wasi_snapshot_preview1::path_rename, wasi_snapshot_preview1::path_symlink, wasi_snapshot_preview1::path_unlink_file, wasi_snapshot_preview1::poll_oneoff, wasi_snapshot_preview1::sched_yield, wasi_snapshot_preview1::sock_accept, wasi_snapshot_preview1::sock_recv, wasi_snapshot_preview1::sock_send, wasi_snapshot_preview1::sock_shutdown} }); } pub mod preview_0 { diff --git a/crates/wasmparser/Cargo.lock b/crates/wasmparser/Cargo.lock new file mode 100644 index 000000000..ae4500e2d --- /dev/null +++ b/crates/wasmparser/Cargo.lock @@ -0,0 +1,629 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "anyhow" +version = "1.0.62" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1485d4d2cc45e7b201ee3767015c96faa5904387c9d87c6efdd0fb511f12d305" + +[[package]] +name = "atty" +version = "0.2.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" +dependencies = [ + "hermit-abi", + "libc", + "winapi", +] + +[[package]] +name = "autocfg" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bstr" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223" +dependencies = [ + "lazy_static", + "memchr", + "regex-automata", + "serde", +] + +[[package]] +name = "bumpalo" +version = "3.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37ccbd214614c6783386c1af30caf03192f17891059cecc394b4fb119e363de3" + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "clap" +version = "2.34.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c" +dependencies = [ + "bitflags", + "textwrap", + "unicode-width", +] + +[[package]] +name = "criterion" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b01d6de93b2b6c65e17c634a26653a29d107b3c98c607c765bf38d041531cd8f" +dependencies = [ + "atty", + "cast", + "clap", + "criterion-plot", + "csv", + "itertools", + "lazy_static", + "num-traits", + "oorandom", + "plotters", + "rayon", + "regex", + "serde", + "serde_cbor", + "serde_derive", + "serde_json", + "tinytemplate", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2673cc8207403546f45f5fd319a974b1e6983ad1a3ee7e6041650013be041876" +dependencies = [ + "cast", + "itertools", +] + +[[package]] +name = "crossbeam-channel" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521" +dependencies = [ + "cfg-if", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc" +dependencies = [ + "cfg-if", + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "045ebe27666471bb549370b4b0b3e51b07f56325befa4284db65fc89c02511b1" +dependencies = [ + "autocfg", + "cfg-if", + "crossbeam-utils", + "memoffset", + "once_cell", + "scopeguard", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51887d4adc7b564537b15adcfb307936f8075dfcd5f00dde9a9f1d29383682bc" +dependencies = [ + "cfg-if", + "once_cell", +] + +[[package]] +name = "csv" +version = "1.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22813a6dc45b335f9bade10bf7271dc477e81113e89eb251a0bc2a8a81c536e1" +dependencies = [ + "bstr", + "csv-core", + "itoa 0.4.8", + "ryu", + "serde", +] + +[[package]] +name = "csv-core" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90" +dependencies = [ + "memchr", +] + +[[package]] +name = "either" +version = "1.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f107b87b6afc2a64fd13cac55fe06d6c8859f12d4b14cbcdd2c67d0976781be" + +[[package]] +name = "getopts" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5" +dependencies = [ + "unicode-width", +] + +[[package]] +name = "half" +version = "1.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7" + +[[package]] +name = "hashbrown" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" + +[[package]] +name = "hermit-abi" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33" +dependencies = [ + "libc", +] + +[[package]] +name = "indexmap" +version = "1.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e" +dependencies = [ + "autocfg", + "hashbrown", +] + +[[package]] +name = "itertools" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4" + +[[package]] +name = "itoa" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c8af84674fe1f223a982c933a0ee1086ac4d4052aa0fb8060c12c6ad838e754" + +[[package]] +name = "js-sys" +version = "0.3.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "258451ab10b34f8af53416d1fdab72c22e805f0c92a1136d59470ec0b11138b2" +dependencies = [ + "wasm-bindgen", +] + +[[package]] +name = "lazy_static" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" + +[[package]] +name = "libc" +version = "0.2.132" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8371e4e5341c3a96db127eb2465ac681ced4c433e01dd0e938adbef26ba93ba5" + +[[package]] +name = "log" +version = "0.4.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "memchr" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d" + +[[package]] +name = "memoffset" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce" +dependencies = [ + "autocfg", +] + +[[package]] +name = "num-traits" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd" +dependencies = [ + "autocfg", +] + +[[package]] +name = "num_cpus" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1" +dependencies = [ + "hermit-abi", + "libc", +] + +[[package]] +name = "once_cell" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "074864da206b4973b84eb91683020dbefd6a8c3f0f38e054d93954e891935e4e" + +[[package]] +name = "oorandom" +version = "11.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575" + +[[package]] +name = "plotters" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9428003b84df1496fb9d6eeee9c5f8145cb41ca375eb0dad204328888832811f" +dependencies = [ + "num-traits", + "plotters-backend", + "plotters-svg", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "plotters-backend" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "193228616381fecdc1224c62e96946dfbc73ff4384fba576e052ff8c1bea8142" + +[[package]] +name = "plotters-svg" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0918736323d1baff32ee0eade54984f6f201ad7e97d5cfb5d6ab4a358529615" +dependencies = [ + "plotters-backend", +] + +[[package]] +name = "proc-macro2" +version = "1.0.43" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a2ca2c61bc9f3d74d2886294ab7b9853abd9c1ad903a3ac7815c58989bb7bab" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rayon" +version = "1.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd99e5772ead8baa5215278c9b15bf92087709e9c1b2d1f97cdb5a183c933a7d" +dependencies = [ + "autocfg", + "crossbeam-deque", + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "258bcdb5ac6dad48491bb2992db6b7cf74878b0384908af124823d118c99683f" +dependencies = [ + "crossbeam-channel", + "crossbeam-deque", + "crossbeam-utils", + "num_cpus", +] + +[[package]] +name = "regex" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c4eb3267174b8c6c2f654116623910a0fef09c4753f8dd83db29c48a0df988b" +dependencies = [ + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" + +[[package]] +name = "regex-syntax" +version = "0.6.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244" + +[[package]] +name = "ryu" +version = "1.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4501abdff3ae82a1c1b477a17252eb69cee9e66eb915c1abaa4f44d873df9f09" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "scopeguard" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" + +[[package]] +name = "serde" +version = "1.0.143" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53e8e5d5b70924f74ff5c6d64d9a5acd91422117c60f48c4e07855238a254553" + +[[package]] +name = "serde_cbor" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5" +dependencies = [ + "half", + "serde", +] + +[[package]] +name = "serde_derive" +version = "1.0.143" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3d8e8de557aee63c26b85b947f5e59b690d0454c753f3adeb5cd7835ab88391" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.83" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38dd04e3c8279e75b31ef29dbdceebfe5ad89f4d0937213c53f7d49d01b3d5a7" +dependencies = [ + "itoa 1.0.3", + "ryu", + "serde", +] + +[[package]] +name = "syn" +version = "1.0.99" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58dbef6ec655055e20b86b15a8cc6d439cca19b667537ac6a1369572d151ab13" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "textwrap" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060" +dependencies = [ + "unicode-width", +] + +[[package]] +name = "tinytemplate" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" +dependencies = [ + "serde", + "serde_json", +] + +[[package]] +name = "unicode-ident" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4f5b37a154999a8f3f98cc23a628d850e154479cd94decf3414696e12e31aaf" + +[[package]] +name = "unicode-width" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973" + +[[package]] +name = "walkdir" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56" +dependencies = [ + "same-file", + "winapi", + "winapi-util", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.82" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc7652e3f6c4706c8d9cd54832c4a4ccb9b5336e2c3bd154d5cccfbf1c1f5f7d" +dependencies = [ + "cfg-if", + "wasm-bindgen-macro", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.82" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "662cd44805586bd52971b9586b1df85cdbbd9112e4ef4d8f41559c334dc6ac3f" +dependencies = [ + "bumpalo", + "log", + "once_cell", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.82" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b260f13d3012071dfb1512849c033b1925038373aea48ced3012c09df952c602" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.82" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5be8e654bdd9b79216c2929ab90721aa82faf65c48cdf08bdc4e7f51357b80da" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.82" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6598dd0bd3c7d51095ff6531a5b23e02acdc81804e30d8f07afb77b7215a140a" + +[[package]] +name = "wasmparser" +version = "0.89.1" +dependencies = [ + "anyhow", + "criterion", + "getopts", + "indexmap", + "once_cell", + "rayon", +] + +[[package]] +name = "web-sys" +version = "0.3.59" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed055ab27f941423197eb86b2035720b1a3ce40504df082cac2ecc6ed73335a1" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178" +dependencies = [ + "winapi", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" diff --git a/crates/wasmparser/Cargo.toml b/crates/wasmparser/Cargo.toml new file mode 100644 index 000000000..4ea5518d7 --- /dev/null +++ b/crates/wasmparser/Cargo.toml @@ -0,0 +1,57 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2021" +name = "wasmparser" +version = "0.89.1" +authors = ["Yury Delendik "] +description = """ +A simple event-driven library for parsing WebAssembly binary files. +""" +homepage = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wasmparser" +readme = "README.md" +keywords = [ + "parser", + "WebAssembly", + "wasm", +] +license = "Apache-2.0 WITH LLVM-exception" +repository = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wasmparser" +resolver = "2" + +[dependencies] +wat = { path = "../wat", version = "1.0.47" } + +[[bench]] +name = "benchmark" +harness = false + +[dependencies.indexmap] +version = "1.8.0" + +[dev-dependencies.anyhow] +version = "1.0" + +[dev-dependencies.criterion] +version = "0.3" + +[dev-dependencies.getopts] +version = "0.2" + +[dev-dependencies.once_cell] +version = "1.13.0" + +[dev-dependencies.rayon] +version = "1.3" + +[features] +deterministic = [] diff --git a/crates/wasmparser/Cargo.toml.orig b/crates/wasmparser/Cargo.toml.orig new file mode 100644 index 000000000..340ebf0d1 --- /dev/null +++ b/crates/wasmparser/Cargo.toml.orig @@ -0,0 +1,35 @@ +[package] +name = "wasmparser" +version = "0.89.1" +authors = ["Yury Delendik "] +license = "Apache-2.0 WITH LLVM-exception" +repository = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wasmparser" +homepage = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wasmparser" +keywords = ["parser", "WebAssembly", "wasm"] +description = """ +A simple event-driven library for parsing WebAssembly binary files. +""" +edition = "2021" + +[dependencies] +indexmap = "1.8.0" + +[dev-dependencies] +anyhow = "1.0" +criterion = "0.3" +getopts = "0.2" +wat = { path = "../wat" } +wast = { path = "../wast" } +rayon = "1.3" +wasmparser-dump = { path = "../dump" } +once_cell = "1.13.0" + +[[bench]] +name = "benchmark" +harness = false + +[features] +# The "deterministic" feature supports only Wasm code with "deterministic" execution +# across any hardware. This feature is very critical for many Blockchain infrastructures +# that rely on deterministic executions of smart contracts across different hardwares. +deterministic = [] diff --git a/crates/wasmparser/LICENSE b/crates/wasmparser/LICENSE new file mode 100644 index 000000000..f9d81955f --- /dev/null +++ b/crates/wasmparser/LICENSE @@ -0,0 +1,220 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +--- LLVM Exceptions to the Apache 2.0 License ---- + +As an exception, if, as a result of your compiling your source code, portions +of this Software are embedded into an Object form of such source code, you +may redistribute such embedded portions in such Object form without complying +with the conditions of Sections 4(a), 4(b) and 4(d) of the License. + +In addition, if you combine or link compiled forms of this Software with +software that is licensed under the GPLv2 ("Combined Software") and if a +court of competent jurisdiction determines that the patent provision (Section +3), the indemnity provision (Section 9) or other Section of the License +conflicts with the conditions of the GPLv2, you may retroactively and +prospectively choose to deem waived or otherwise exclude such Section(s) of +the License, but only in their entirety and only with respect to the Combined +Software. + diff --git a/crates/wasmparser/README.md b/crates/wasmparser/README.md new file mode 100644 index 000000000..d40b38b55 --- /dev/null +++ b/crates/wasmparser/README.md @@ -0,0 +1,36 @@ +# The WebAssembly binary file decoder in Rust + +**A [Bytecode Alliance](https://bytecodealliance.org/) project** + +[![crates.io link](https://img.shields.io/crates/v/wasmparser.svg)](https://crates.io/crates/wasmparser) +[![docs.rs docs](https://img.shields.io/static/v1?label=docs&message=wasmparser&color=blue&style=flat-square)](https://docs.rs/wasmparser/) + +The decoder library provides lightweight and fast decoding/parsing of WebAssembly binary files. + +The other goal is minimal memory footprint. For this reason, there is no AST or IR of WebAssembly data. + +See also its sibling at https://github.com/wasdk/wasmparser + + +## Documentation + +The documentation and examples can be found at the https://docs.rs/wasmparser/ + + +## Fuzzing + +To fuzz test wasmparser.rs, switch to a nightly Rust compiler and install [cargo-fuzz]: + +``` +cargo install cargo-fuzz +``` + +Then, from the root of the repository, run: + +``` +cargo fuzz run parse +``` + +If you want to use files as seeds for the fuzzer, add them to `fuzz/corpus/parse/` and restart cargo-fuzz. + +[cargo-fuzz]: https://github.com/rust-fuzz/cargo-fuzz diff --git a/crates/wasmparser/benches/.gitignore b/crates/wasmparser/benches/.gitignore new file mode 100644 index 000000000..45d4a4727 --- /dev/null +++ b/crates/wasmparser/benches/.gitignore @@ -0,0 +1 @@ +!*.wasm diff --git a/crates/wasmparser/benches/benchmark.rs b/crates/wasmparser/benches/benchmark.rs new file mode 100644 index 000000000..324f8f2b4 --- /dev/null +++ b/crates/wasmparser/benches/benchmark.rs @@ -0,0 +1,914 @@ +#[macro_use] +extern crate criterion; + +use anyhow::Result; +use criterion::Criterion; +use once_cell::unsync::Lazy; +use std::fs; +use std::path::Path; +use std::path::PathBuf; +use wasmparser::{ + BlockType, BrTable, DataKind, ElementKind, Ieee32, Ieee64, MemoryImmediate, Parser, Payload, + SIMDLaneIndex, ValType, Validator, VisitOperator, WasmFeatures, V128, +}; + +/// A benchmark input. +pub struct BenchmarkInput { + /// The path to the benchmark file important for handling errors. + pub path: PathBuf, + /// The encoded Wasm module that is run by the benchmark. + pub wasm: Vec, +} + +impl BenchmarkInput { + /// Creates a new benchmark input. + pub fn new(test_path: PathBuf, encoded_wasm: Vec) -> Self { + Self { + path: test_path, + wasm: encoded_wasm, + } + } +} + +/// Returns a vector of all found benchmark input files under the given directory. +/// +/// Benchmark input files can be `.wat` or `.wast` formatted files. +/// For `.wast` files we pull out all the module directives and run them in the benchmarks. +fn collect_test_files(path: &Path, list: &mut Vec) -> Result<()> { + for entry in path.read_dir()? { + let entry = entry?; + let path = entry.path(); + if path.is_dir() { + collect_test_files(&path, list)?; + continue; + } + match path.extension().and_then(|ext| ext.to_str()) { + Some("wasm") => { + let wasm = fs::read(&path)?; + list.push(BenchmarkInput::new(path, wasm)); + } + Some("wat") | Some("txt") => { + if let Ok(wasm) = wat::parse_file(&path) { + list.push(BenchmarkInput::new(path, wasm)); + } + } + Some("wast") => { + let contents = fs::read_to_string(&path)?; + let buf = match wast::parser::ParseBuffer::new(&contents) { + Ok(buf) => buf, + Err(_) => continue, + }; + let wast: wast::Wast<'_> = match wast::parser::parse(&buf) { + Ok(wast) => wast, + Err(_) => continue, + }; + for directive in wast.directives { + match directive { + wast::WastDirective::Wat(mut module) => { + let wasm = module.encode()?; + list.push(BenchmarkInput::new(path.clone(), wasm)); + } + _ => continue, + } + } + } + _ => (), + } + } + Ok(()) +} + +/// Reads the input given the Wasm parser or validator. +/// +/// The `path` specifies which benchmark input file we are currently operating on +/// so that we can report better errors in case of failures. +fn read_all_wasm(wasm: &[u8]) -> Result<()> { + use Payload::*; + for item in Parser::new(0).parse_all(wasm) { + match item? { + TypeSection(s) => { + for item in s { + item?; + } + } + ImportSection(s) => { + for item in s { + item?; + } + } + FunctionSection(s) => { + for item in s { + item?; + } + } + TableSection(s) => { + for item in s { + item?; + } + } + MemorySection(s) => { + for item in s { + item?; + } + } + TagSection(s) => { + for item in s { + item?; + } + } + GlobalSection(s) => { + for item in s { + for op in item?.init_expr.get_operators_reader() { + op?; + } + } + } + ExportSection(s) => { + for item in s { + item?; + } + } + ElementSection(s) => { + for item in s { + let item = item?; + if let ElementKind::Active { offset_expr, .. } = item.kind { + for op in offset_expr.get_operators_reader() { + op?; + } + } + for op in item.items.get_items_reader()? { + op?; + } + } + } + DataSection(s) => { + for item in s { + let item = item?; + if let DataKind::Active { offset_expr, .. } = item.kind { + for op in offset_expr.get_operators_reader() { + op?; + } + } + } + } + CodeSectionEntry(body) => { + let mut reader = body.get_binary_reader(); + for _ in 0..reader.read_var_u32()? { + reader.read_var_u32()?; + reader.read_val_type()?; + } + while !reader.eof() { + reader.visit_operator(&mut NopVisit)?; + } + } + + // Component sections + ModuleSection { .. } => {} + InstanceSection(s) => { + for item in s { + item?; + } + } + AliasSection(s) => { + for item in s { + item?; + } + } + CoreTypeSection(s) => { + for item in s { + item?; + } + } + ComponentSection { .. } => {} + ComponentInstanceSection(s) => { + for item in s { + item?; + } + } + ComponentAliasSection(s) => { + for item in s { + item?; + } + } + ComponentTypeSection(s) => { + for item in s { + item?; + } + } + ComponentCanonicalSection(s) => { + for item in s { + item?; + } + } + ComponentStartSection { .. } => {} + ComponentImportSection(s) => { + for item in s { + item?; + } + } + ComponentExportSection(s) => { + for item in s { + item?; + } + } + + Version { .. } + | StartSection { .. } + | DataCountSection { .. } + | UnknownSection { .. } + | CustomSection { .. } + | CodeSectionStart { .. } + | End(_) => {} + } + } + Ok(()) +} + +/// Returns the default benchmark inputs that are proper `wasmparser` benchmark +/// test inputs. +fn collect_benchmark_inputs() -> Vec { + let mut ret = Vec::new(); + collect_test_files("../../tests".as_ref(), &mut ret).unwrap(); + // Sort to ideally get more deterministic perf that ignores filesystems + ret.sort_by_key(|p| p.path.clone()); + ret +} + +fn define_benchmarks(c: &mut Criterion) { + fn validator() -> Validator { + Validator::new_with_features(WasmFeatures { + reference_types: true, + multi_value: true, + simd: true, + relaxed_simd: true, + exceptions: true, + component_model: true, + bulk_memory: true, + threads: true, + tail_call: true, + multi_memory: true, + memory64: true, + extended_const: true, + deterministic_only: false, + mutable_global: true, + saturating_float_to_int: true, + sign_extension: true, + }) + } + + let test_inputs = once_cell::unsync::Lazy::new(collect_benchmark_inputs); + + let parse_inputs = once_cell::unsync::Lazy::new(|| { + let mut list = Vec::new(); + for input in test_inputs.iter() { + if read_all_wasm(&input.wasm).is_ok() { + list.push(&input.wasm); + } + } + list + }); + c.bench_function("parse/tests", |b| { + Lazy::force(&parse_inputs); + b.iter(|| { + for wasm in parse_inputs.iter() { + read_all_wasm(wasm).unwrap(); + } + }) + }); + + let validate_inputs = once_cell::unsync::Lazy::new(|| { + let mut list = Vec::new(); + for input in test_inputs.iter() { + if validator().validate_all(&input.wasm).is_ok() { + list.push(&input.wasm); + } + } + list + }); + c.bench_function("validate/tests", |b| { + Lazy::force(&validate_inputs); + b.iter(|| { + for wasm in validate_inputs.iter() { + validator().validate_all(wasm).unwrap(); + } + }) + }); + + for file in std::fs::read_dir("benches").unwrap() { + let file = file.unwrap(); + let path = file.path(); + if path.extension().and_then(|s| s.to_str()) != Some("wasm") { + continue; + } + let name = path.file_stem().unwrap().to_str().unwrap(); + let wasm = Lazy::new(|| std::fs::read(&path).unwrap()); + c.bench_function(&format!("validate/{name}"), |b| { + Lazy::force(&wasm); + b.iter(|| { + validator().validate_all(&wasm).unwrap(); + }) + }); + c.bench_function(&format!("parse/{name}"), |b| { + Lazy::force(&wasm); + b.iter(|| { + read_all_wasm(&wasm).unwrap(); + }) + }); + } +} + +criterion_group!(benchmark, define_benchmarks); +criterion_main!(benchmark); + +struct NopVisit; + +#[allow(unused_variables)] +impl<'a> VisitOperator<'a> for NopVisit { + type Output = (); + + fn visit_nop(&mut self, offset: usize) {} + fn visit_unreachable(&mut self, offset: usize) {} + fn visit_block(&mut self, offset: usize, ty: BlockType) {} + fn visit_loop(&mut self, offset: usize, ty: BlockType) {} + fn visit_if(&mut self, offset: usize, ty: BlockType) {} + fn visit_else(&mut self, offset: usize) {} + fn visit_try(&mut self, offset: usize, ty: BlockType) {} + fn visit_catch(&mut self, offset: usize, index: u32) {} + fn visit_throw(&mut self, offset: usize, index: u32) {} + fn visit_rethrow(&mut self, offset: usize, relative_depth: u32) {} + fn visit_delegate(&mut self, offset: usize, relative_depth: u32) {} + fn visit_catch_all(&mut self, offset: usize) {} + fn visit_end(&mut self, offset: usize) {} + fn visit_br(&mut self, offset: usize, relative_depth: u32) {} + fn visit_br_if(&mut self, offset: usize, relative_depth: u32) {} + fn visit_br_table(&mut self, offset: usize, table: &BrTable<'a>) { + for target in table.targets() { + target.unwrap(); + } + } + fn visit_return(&mut self, offset: usize) {} + fn visit_call(&mut self, offset: usize, function_index: u32) {} + fn visit_return_call(&mut self, offset: usize, function_index: u32) {} + fn visit_call_indirect(&mut self, offset: usize, index: u32, table_index: u32, table_byte: u8) { + } + fn visit_return_call_indirect(&mut self, offset: usize, index: u32, table_index: u32) {} + fn visit_drop(&mut self, offset: usize) {} + fn visit_select(&mut self, offset: usize) {} + fn visit_typed_select(&mut self, offset: usize, ty: ValType) {} + fn visit_local_get(&mut self, offset: usize, local_index: u32) {} + fn visit_local_set(&mut self, offset: usize, local_index: u32) {} + fn visit_local_tee(&mut self, offset: usize, local_index: u32) {} + fn visit_global_get(&mut self, offset: usize, global_index: u32) {} + fn visit_global_set(&mut self, offset: usize, global_index: u32) {} + fn visit_i32_load(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_load(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_f32_load(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_f64_load(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_load8_s(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_load8_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_load16_s(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_load16_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_load8_s(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_load8_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_load16_s(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_load16_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_load32_s(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_load32_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_store(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_store(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_f32_store(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_f64_store(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_store8(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_store16(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_store8(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_store16(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_store32(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_memory_size(&mut self, offset: usize, mem: u32, mem_byte: u8) {} + fn visit_memory_grow(&mut self, offset: usize, mem: u32, mem_byte: u8) {} + fn visit_i32_const(&mut self, offset: usize, value: i32) {} + fn visit_i64_const(&mut self, offset: usize, value: i64) {} + fn visit_f32_const(&mut self, offset: usize, value: Ieee32) {} + fn visit_f64_const(&mut self, offset: usize, value: Ieee64) {} + fn visit_i32_eqz(&mut self, offset: usize) {} + fn visit_i32_eq(&mut self, offset: usize) {} + fn visit_i32_ne(&mut self, offset: usize) {} + fn visit_i32_lt_s(&mut self, offset: usize) {} + fn visit_i32_lt_u(&mut self, offset: usize) {} + fn visit_i32_gt_s(&mut self, offset: usize) {} + fn visit_i32_gt_u(&mut self, offset: usize) {} + fn visit_i32_le_s(&mut self, offset: usize) {} + fn visit_i32_le_u(&mut self, offset: usize) {} + fn visit_i32_ge_s(&mut self, offset: usize) {} + fn visit_i32_ge_u(&mut self, offset: usize) {} + fn visit_i64_eqz(&mut self, offset: usize) {} + fn visit_i64_eq(&mut self, offset: usize) {} + fn visit_i64_ne(&mut self, offset: usize) {} + fn visit_i64_lt_s(&mut self, offset: usize) {} + fn visit_i64_lt_u(&mut self, offset: usize) {} + fn visit_i64_gt_s(&mut self, offset: usize) {} + fn visit_i64_gt_u(&mut self, offset: usize) {} + fn visit_i64_le_s(&mut self, offset: usize) {} + fn visit_i64_le_u(&mut self, offset: usize) {} + fn visit_i64_ge_s(&mut self, offset: usize) {} + fn visit_i64_ge_u(&mut self, offset: usize) {} + fn visit_f32_eq(&mut self, offset: usize) {} + fn visit_f32_ne(&mut self, offset: usize) {} + fn visit_f32_lt(&mut self, offset: usize) {} + fn visit_f32_gt(&mut self, offset: usize) {} + fn visit_f32_le(&mut self, offset: usize) {} + fn visit_f32_ge(&mut self, offset: usize) {} + fn visit_f64_eq(&mut self, offset: usize) {} + fn visit_f64_ne(&mut self, offset: usize) {} + fn visit_f64_lt(&mut self, offset: usize) {} + fn visit_f64_gt(&mut self, offset: usize) {} + fn visit_f64_le(&mut self, offset: usize) {} + fn visit_f64_ge(&mut self, offset: usize) {} + fn visit_i32_clz(&mut self, offset: usize) {} + fn visit_i32_ctz(&mut self, offset: usize) {} + fn visit_i32_popcnt(&mut self, offset: usize) {} + fn visit_i32_add(&mut self, offset: usize) {} + fn visit_i32_sub(&mut self, offset: usize) {} + fn visit_i32_mul(&mut self, offset: usize) {} + fn visit_i32_div_s(&mut self, offset: usize) {} + fn visit_i32_div_u(&mut self, offset: usize) {} + fn visit_i32_rem_s(&mut self, offset: usize) {} + fn visit_i32_rem_u(&mut self, offset: usize) {} + fn visit_i32_and(&mut self, offset: usize) {} + fn visit_i32_or(&mut self, offset: usize) {} + fn visit_i32_xor(&mut self, offset: usize) {} + fn visit_i32_shl(&mut self, offset: usize) {} + fn visit_i32_shr_s(&mut self, offset: usize) {} + fn visit_i32_shr_u(&mut self, offset: usize) {} + fn visit_i32_rotl(&mut self, offset: usize) {} + fn visit_i32_rotr(&mut self, offset: usize) {} + fn visit_i64_clz(&mut self, offset: usize) {} + fn visit_i64_ctz(&mut self, offset: usize) {} + fn visit_i64_popcnt(&mut self, offset: usize) {} + fn visit_i64_add(&mut self, offset: usize) {} + fn visit_i64_sub(&mut self, offset: usize) {} + fn visit_i64_mul(&mut self, offset: usize) {} + fn visit_i64_div_s(&mut self, offset: usize) {} + fn visit_i64_div_u(&mut self, offset: usize) {} + fn visit_i64_rem_s(&mut self, offset: usize) {} + fn visit_i64_rem_u(&mut self, offset: usize) {} + fn visit_i64_and(&mut self, offset: usize) {} + fn visit_i64_or(&mut self, offset: usize) {} + fn visit_i64_xor(&mut self, offset: usize) {} + fn visit_i64_shl(&mut self, offset: usize) {} + fn visit_i64_shr_s(&mut self, offset: usize) {} + fn visit_i64_shr_u(&mut self, offset: usize) {} + fn visit_i64_rotl(&mut self, offset: usize) {} + fn visit_i64_rotr(&mut self, offset: usize) {} + fn visit_f32_abs(&mut self, offset: usize) {} + fn visit_f32_neg(&mut self, offset: usize) {} + fn visit_f32_ceil(&mut self, offset: usize) {} + fn visit_f32_floor(&mut self, offset: usize) {} + fn visit_f32_trunc(&mut self, offset: usize) {} + fn visit_f32_nearest(&mut self, offset: usize) {} + fn visit_f32_sqrt(&mut self, offset: usize) {} + fn visit_f32_add(&mut self, offset: usize) {} + fn visit_f32_sub(&mut self, offset: usize) {} + fn visit_f32_mul(&mut self, offset: usize) {} + fn visit_f32_div(&mut self, offset: usize) {} + fn visit_f32_min(&mut self, offset: usize) {} + fn visit_f32_max(&mut self, offset: usize) {} + fn visit_f32_copysign(&mut self, offset: usize) {} + fn visit_f64_abs(&mut self, offset: usize) {} + fn visit_f64_neg(&mut self, offset: usize) {} + fn visit_f64_ceil(&mut self, offset: usize) {} + fn visit_f64_floor(&mut self, offset: usize) {} + fn visit_f64_trunc(&mut self, offset: usize) {} + fn visit_f64_nearest(&mut self, offset: usize) {} + fn visit_f64_sqrt(&mut self, offset: usize) {} + fn visit_f64_add(&mut self, offset: usize) {} + fn visit_f64_sub(&mut self, offset: usize) {} + fn visit_f64_mul(&mut self, offset: usize) {} + fn visit_f64_div(&mut self, offset: usize) {} + fn visit_f64_min(&mut self, offset: usize) {} + fn visit_f64_max(&mut self, offset: usize) {} + fn visit_f64_copysign(&mut self, offset: usize) {} + fn visit_i32_wrap_i64(&mut self, offset: usize) {} + fn visit_i32_trunc_f32s(&mut self, offset: usize) {} + fn visit_i32_trunc_f32u(&mut self, offset: usize) {} + fn visit_i32_trunc_f64s(&mut self, offset: usize) {} + fn visit_i32_trunc_f64u(&mut self, offset: usize) {} + fn visit_i64_extend_i32s(&mut self, offset: usize) {} + fn visit_i64_extend_i32u(&mut self, offset: usize) {} + fn visit_i64_trunc_f32s(&mut self, offset: usize) {} + fn visit_i64_trunc_f32u(&mut self, offset: usize) {} + fn visit_i64_trunc_f64s(&mut self, offset: usize) {} + fn visit_i64_trunc_f64u(&mut self, offset: usize) {} + fn visit_f32_convert_i32s(&mut self, offset: usize) {} + fn visit_f32_convert_i32u(&mut self, offset: usize) {} + fn visit_f32_convert_i64s(&mut self, offset: usize) {} + fn visit_f32_convert_i64u(&mut self, offset: usize) {} + fn visit_f32_demote_f64(&mut self, offset: usize) {} + fn visit_f64_convert_i32s(&mut self, offset: usize) {} + fn visit_f64_convert_i32u(&mut self, offset: usize) {} + fn visit_f64_convert_i64s(&mut self, offset: usize) {} + fn visit_f64_convert_i64u(&mut self, offset: usize) {} + fn visit_f64_promote_f32(&mut self, offset: usize) {} + fn visit_i32_reinterpret_f32(&mut self, offset: usize) {} + fn visit_i64_reinterpret_f64(&mut self, offset: usize) {} + fn visit_f32_reinterpret_i32(&mut self, offset: usize) {} + fn visit_f64_reinterpret_i64(&mut self, offset: usize) {} + fn visit_i32_trunc_sat_f32s(&mut self, offset: usize) {} + fn visit_i32_trunc_sat_f32u(&mut self, offset: usize) {} + fn visit_i32_trunc_sat_f64s(&mut self, offset: usize) {} + fn visit_i32_trunc_sat_f64u(&mut self, offset: usize) {} + fn visit_i64_trunc_sat_f32s(&mut self, offset: usize) {} + fn visit_i64_trunc_sat_f32u(&mut self, offset: usize) {} + fn visit_i64_trunc_sat_f64s(&mut self, offset: usize) {} + fn visit_i64_trunc_sat_f64u(&mut self, offset: usize) {} + fn visit_i32_extend8_s(&mut self, offset: usize) {} + fn visit_i32_extend16_s(&mut self, offset: usize) {} + fn visit_i64_extend8_s(&mut self, offset: usize) {} + fn visit_i64_extend16_s(&mut self, offset: usize) {} + fn visit_i64_extend32_s(&mut self, offset: usize) {} + fn visit_i32_atomic_load(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_load16_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_load8_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_load(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_load32_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_load16_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_load8_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_store(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_store16(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_store8(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_store(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_store32(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_store16(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_store8(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw_add(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw_sub(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw_and(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw_or(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw_xor(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw16_add_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw16_sub_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw16_and_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw16_or_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw16_xor_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw8_add_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw8_sub_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw8_and_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw8_or_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw8_xor_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw_add(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw_sub(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw_and(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw_or(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw_xor(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw32_add_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw32_sub_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw32_and_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw32_or_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw32_xor_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw16_add_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw16_sub_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw16_and_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw16_or_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw16_xor_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw8_add_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw8_sub_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw8_and_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw8_or_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw8_xor_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw_xchg(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw16_xchg_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw8_xchg_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw_cmpxchg(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw16_cmpxchg_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i32_atomic_rmw8_cmpxchg_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw_xchg(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw32_xchg_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw16_xchg_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw8_xchg_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw_cmpxchg(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw32_cmpxchg_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw16_cmpxchg_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_i64_atomic_rmw8_cmpxchg_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_memory_atomic_notify(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_memory_atomic_wait32(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_memory_atomic_wait64(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_atomic_fence(&mut self, offset: usize, flags: u8) {} + fn visit_ref_null(&mut self, offset: usize, ty: ValType) {} + fn visit_ref_is_null(&mut self, offset: usize) {} + fn visit_ref_func(&mut self, offset: usize, function_index: u32) {} + fn visit_v128_load(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_v128_store(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_v128_const(&mut self, offset: usize, value: V128) {} + fn visit_i8x16_splat(&mut self, offset: usize) {} + fn visit_i16x8_splat(&mut self, offset: usize) {} + fn visit_i32x4_splat(&mut self, offset: usize) {} + fn visit_i64x2_splat(&mut self, offset: usize) {} + fn visit_f32x4_splat(&mut self, offset: usize) {} + fn visit_f64x2_splat(&mut self, offset: usize) {} + fn visit_i8x16_extract_lane_s(&mut self, offset: usize, lane: SIMDLaneIndex) {} + fn visit_i8x16_extract_lane_u(&mut self, offset: usize, lane: SIMDLaneIndex) {} + fn visit_i16x8_extract_lane_s(&mut self, offset: usize, lane: SIMDLaneIndex) {} + fn visit_i16x8_extract_lane_u(&mut self, offset: usize, lane: SIMDLaneIndex) {} + fn visit_i32x4_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) {} + fn visit_i8x16_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) {} + fn visit_i16x8_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) {} + fn visit_i32x4_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) {} + fn visit_i64x2_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) {} + fn visit_i64x2_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) {} + fn visit_f32x4_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) {} + fn visit_f32x4_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) {} + fn visit_f64x2_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) {} + fn visit_f64x2_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) {} + fn visit_f32x4_eq(&mut self, offset: usize) {} + fn visit_f32x4_ne(&mut self, offset: usize) {} + fn visit_f32x4_lt(&mut self, offset: usize) {} + fn visit_f32x4_gt(&mut self, offset: usize) {} + fn visit_f32x4_le(&mut self, offset: usize) {} + fn visit_f32x4_ge(&mut self, offset: usize) {} + fn visit_f64x2_eq(&mut self, offset: usize) {} + fn visit_f64x2_ne(&mut self, offset: usize) {} + fn visit_f64x2_lt(&mut self, offset: usize) {} + fn visit_f64x2_gt(&mut self, offset: usize) {} + fn visit_f64x2_le(&mut self, offset: usize) {} + fn visit_f64x2_ge(&mut self, offset: usize) {} + fn visit_f32x4_add(&mut self, offset: usize) {} + fn visit_f32x4_sub(&mut self, offset: usize) {} + fn visit_f32x4_mul(&mut self, offset: usize) {} + fn visit_f32x4_div(&mut self, offset: usize) {} + fn visit_f32x4_min(&mut self, offset: usize) {} + fn visit_f32x4_max(&mut self, offset: usize) {} + fn visit_f32x4_p_min(&mut self, offset: usize) {} + fn visit_f32x4_p_max(&mut self, offset: usize) {} + fn visit_f64x2_add(&mut self, offset: usize) {} + fn visit_f64x2_sub(&mut self, offset: usize) {} + fn visit_f64x2_mul(&mut self, offset: usize) {} + fn visit_f64x2_div(&mut self, offset: usize) {} + fn visit_f64x2_min(&mut self, offset: usize) {} + fn visit_f64x2_max(&mut self, offset: usize) {} + fn visit_f64x2_p_min(&mut self, offset: usize) {} + fn visit_f64x2_p_max(&mut self, offset: usize) {} + fn visit_f32x4_relaxed_min(&mut self, offset: usize) {} + fn visit_f32x4_relaxed_max(&mut self, offset: usize) {} + fn visit_f64x2_relaxed_min(&mut self, offset: usize) {} + fn visit_f64x2_relaxed_max(&mut self, offset: usize) {} + fn visit_i8x16_eq(&mut self, offset: usize) {} + fn visit_i8x16_ne(&mut self, offset: usize) {} + fn visit_i8x16_lt_s(&mut self, offset: usize) {} + fn visit_i8x16_lt_u(&mut self, offset: usize) {} + fn visit_i8x16_gt_s(&mut self, offset: usize) {} + fn visit_i8x16_gt_u(&mut self, offset: usize) {} + fn visit_i8x16_le_s(&mut self, offset: usize) {} + fn visit_i8x16_le_u(&mut self, offset: usize) {} + fn visit_i8x16_ge_s(&mut self, offset: usize) {} + fn visit_i8x16_ge_u(&mut self, offset: usize) {} + fn visit_i16x8_eq(&mut self, offset: usize) {} + fn visit_i16x8_ne(&mut self, offset: usize) {} + fn visit_i16x8_lt_s(&mut self, offset: usize) {} + fn visit_i16x8_lt_u(&mut self, offset: usize) {} + fn visit_i16x8_gt_s(&mut self, offset: usize) {} + fn visit_i16x8_gt_u(&mut self, offset: usize) {} + fn visit_i16x8_le_s(&mut self, offset: usize) {} + fn visit_i16x8_le_u(&mut self, offset: usize) {} + fn visit_i16x8_ge_s(&mut self, offset: usize) {} + fn visit_i16x8_ge_u(&mut self, offset: usize) {} + fn visit_i32x4_eq(&mut self, offset: usize) {} + fn visit_i32x4_ne(&mut self, offset: usize) {} + fn visit_i32x4_lt_s(&mut self, offset: usize) {} + fn visit_i32x4_lt_u(&mut self, offset: usize) {} + fn visit_i32x4_gt_s(&mut self, offset: usize) {} + fn visit_i32x4_gt_u(&mut self, offset: usize) {} + fn visit_i32x4_le_s(&mut self, offset: usize) {} + fn visit_i32x4_le_u(&mut self, offset: usize) {} + fn visit_i32x4_ge_s(&mut self, offset: usize) {} + fn visit_i32x4_ge_u(&mut self, offset: usize) {} + fn visit_i64x2_eq(&mut self, offset: usize) {} + fn visit_i64x2_ne(&mut self, offset: usize) {} + fn visit_i64x2_lt_s(&mut self, offset: usize) {} + fn visit_i64x2_gt_s(&mut self, offset: usize) {} + fn visit_i64x2_le_s(&mut self, offset: usize) {} + fn visit_i64x2_ge_s(&mut self, offset: usize) {} + fn visit_v128_and(&mut self, offset: usize) {} + fn visit_v128_and_not(&mut self, offset: usize) {} + fn visit_v128_or(&mut self, offset: usize) {} + fn visit_v128_xor(&mut self, offset: usize) {} + fn visit_i8x16_add(&mut self, offset: usize) {} + fn visit_i8x16_add_sat_s(&mut self, offset: usize) {} + fn visit_i8x16_add_sat_u(&mut self, offset: usize) {} + fn visit_i8x16_sub(&mut self, offset: usize) {} + fn visit_i8x16_sub_sat_s(&mut self, offset: usize) {} + fn visit_i8x16_sub_sat_u(&mut self, offset: usize) {} + fn visit_i8x16_min_s(&mut self, offset: usize) {} + fn visit_i8x16_min_u(&mut self, offset: usize) {} + fn visit_i8x16_max_s(&mut self, offset: usize) {} + fn visit_i8x16_max_u(&mut self, offset: usize) {} + fn visit_i16x8_add(&mut self, offset: usize) {} + fn visit_i16x8_add_sat_s(&mut self, offset: usize) {} + fn visit_i16x8_add_sat_u(&mut self, offset: usize) {} + fn visit_i16x8_sub(&mut self, offset: usize) {} + fn visit_i16x8_sub_sat_s(&mut self, offset: usize) {} + fn visit_i16x8_sub_sat_u(&mut self, offset: usize) {} + fn visit_i16x8_mul(&mut self, offset: usize) {} + fn visit_i16x8_min_s(&mut self, offset: usize) {} + fn visit_i16x8_min_u(&mut self, offset: usize) {} + fn visit_i16x8_max_s(&mut self, offset: usize) {} + fn visit_i16x8_max_u(&mut self, offset: usize) {} + fn visit_i32x4_add(&mut self, offset: usize) {} + fn visit_i32x4_sub(&mut self, offset: usize) {} + fn visit_i32x4_mul(&mut self, offset: usize) {} + fn visit_i32x4_min_s(&mut self, offset: usize) {} + fn visit_i32x4_min_u(&mut self, offset: usize) {} + fn visit_i32x4_max_s(&mut self, offset: usize) {} + fn visit_i32x4_max_u(&mut self, offset: usize) {} + fn visit_i32x4_dot_i16x8_s(&mut self, offset: usize) {} + fn visit_i64x2_add(&mut self, offset: usize) {} + fn visit_i64x2_sub(&mut self, offset: usize) {} + fn visit_i64x2_mul(&mut self, offset: usize) {} + fn visit_i8x16_rounding_average_u(&mut self, offset: usize) {} + fn visit_i16x8_rounding_average_u(&mut self, offset: usize) {} + fn visit_i8x16_narrow_i16x8_s(&mut self, offset: usize) {} + fn visit_i8x16_narrow_i16x8_u(&mut self, offset: usize) {} + fn visit_i16x8_narrow_i32x4_s(&mut self, offset: usize) {} + fn visit_i16x8_narrow_i32x4_u(&mut self, offset: usize) {} + fn visit_i16x8_ext_mul_low_i8x16_s(&mut self, offset: usize) {} + fn visit_i16x8_ext_mul_high_i8x16_s(&mut self, offset: usize) {} + fn visit_i16x8_ext_mul_low_i8x16_u(&mut self, offset: usize) {} + fn visit_i16x8_ext_mul_high_i8x16_u(&mut self, offset: usize) {} + fn visit_i32x4_ext_mul_low_i16x8_s(&mut self, offset: usize) {} + fn visit_i32x4_ext_mul_high_i16x8_s(&mut self, offset: usize) {} + fn visit_i32x4_ext_mul_low_i16x8_u(&mut self, offset: usize) {} + fn visit_i32x4_ext_mul_high_i16x8_u(&mut self, offset: usize) {} + fn visit_i64x2_ext_mul_low_i32x4_s(&mut self, offset: usize) {} + fn visit_i64x2_ext_mul_high_i32x4_s(&mut self, offset: usize) {} + fn visit_i64x2_ext_mul_low_i32x4_u(&mut self, offset: usize) {} + fn visit_i64x2_ext_mul_high_i32x4_u(&mut self, offset: usize) {} + fn visit_i16x8_q15_mulr_sat_s(&mut self, offset: usize) {} + fn visit_f32x4_ceil(&mut self, offset: usize) {} + fn visit_f32x4_floor(&mut self, offset: usize) {} + fn visit_f32x4_trunc(&mut self, offset: usize) {} + fn visit_f32x4_nearest(&mut self, offset: usize) {} + fn visit_f64x2_ceil(&mut self, offset: usize) {} + fn visit_f64x2_floor(&mut self, offset: usize) {} + fn visit_f64x2_trunc(&mut self, offset: usize) {} + fn visit_f64x2_nearest(&mut self, offset: usize) {} + fn visit_f32x4_abs(&mut self, offset: usize) {} + fn visit_f32x4_neg(&mut self, offset: usize) {} + fn visit_f32x4_sqrt(&mut self, offset: usize) {} + fn visit_f64x2_abs(&mut self, offset: usize) {} + fn visit_f64x2_neg(&mut self, offset: usize) {} + fn visit_f64x2_sqrt(&mut self, offset: usize) {} + fn visit_f32x4_demote_f64x2_zero(&mut self, offset: usize) {} + fn visit_f64x2_promote_low_f32x4(&mut self, offset: usize) {} + fn visit_f64x2_convert_low_i32x4_s(&mut self, offset: usize) {} + fn visit_f64x2_convert_low_i32x4_u(&mut self, offset: usize) {} + fn visit_i32x4_trunc_sat_f32x4_s(&mut self, offset: usize) {} + fn visit_i32x4_trunc_sat_f32x4_u(&mut self, offset: usize) {} + fn visit_i32x4_trunc_sat_f64x2_s_zero(&mut self, offset: usize) {} + fn visit_i32x4_trunc_sat_f64x2_u_zero(&mut self, offset: usize) {} + fn visit_f32x4_convert_i32x4_s(&mut self, offset: usize) {} + fn visit_f32x4_convert_i32x4_u(&mut self, offset: usize) {} + fn visit_v128_not(&mut self, offset: usize) {} + fn visit_i8x16_abs(&mut self, offset: usize) {} + fn visit_i8x16_neg(&mut self, offset: usize) {} + fn visit_i8x16_popcnt(&mut self, offset: usize) {} + fn visit_i16x8_abs(&mut self, offset: usize) {} + fn visit_i16x8_neg(&mut self, offset: usize) {} + fn visit_i32x4_abs(&mut self, offset: usize) {} + fn visit_i32x4_neg(&mut self, offset: usize) {} + fn visit_i64x2_abs(&mut self, offset: usize) {} + fn visit_i64x2_neg(&mut self, offset: usize) {} + fn visit_i16x8_extend_low_i8x16_s(&mut self, offset: usize) {} + fn visit_i16x8_extend_high_i8x16_s(&mut self, offset: usize) {} + fn visit_i16x8_extend_low_i8x16_u(&mut self, offset: usize) {} + fn visit_i16x8_extend_high_i8x16_u(&mut self, offset: usize) {} + fn visit_i32x4_extend_low_i16x8_s(&mut self, offset: usize) {} + fn visit_i32x4_extend_high_i16x8_s(&mut self, offset: usize) {} + fn visit_i32x4_extend_low_i16x8_u(&mut self, offset: usize) {} + fn visit_i32x4_extend_high_i16x8_u(&mut self, offset: usize) {} + fn visit_i64x2_extend_low_i32x4_s(&mut self, offset: usize) {} + fn visit_i64x2_extend_high_i32x4_s(&mut self, offset: usize) {} + fn visit_i64x2_extend_low_i32x4_u(&mut self, offset: usize) {} + fn visit_i64x2_extend_high_i32x4_u(&mut self, offset: usize) {} + fn visit_i16x8_ext_add_pairwise_i8x16_s(&mut self, offset: usize) {} + fn visit_i16x8_ext_add_pairwise_i8x16_u(&mut self, offset: usize) {} + fn visit_i32x4_ext_add_pairwise_i16x8_s(&mut self, offset: usize) {} + fn visit_i32x4_ext_add_pairwise_i16x8_u(&mut self, offset: usize) {} + fn visit_i32x4_relaxed_trunc_sat_f32x4_s(&mut self, offset: usize) {} + fn visit_i32x4_relaxed_trunc_sat_f32x4_u(&mut self, offset: usize) {} + fn visit_i32x4_relaxed_trunc_sat_f64x2_s_zero(&mut self, offset: usize) {} + fn visit_i32x4_relaxed_trunc_sat_f64x2_u_zero(&mut self, offset: usize) {} + fn visit_v128_bitselect(&mut self, offset: usize) {} + fn visit_f32x4_fma(&mut self, offset: usize) {} + fn visit_f32x4_fms(&mut self, offset: usize) {} + fn visit_f64x2_fma(&mut self, offset: usize) {} + fn visit_f64x2_fms(&mut self, offset: usize) {} + fn visit_i8x16_lane_select(&mut self, offset: usize) {} + fn visit_i16x8_lane_select(&mut self, offset: usize) {} + fn visit_i32x4_lane_select(&mut self, offset: usize) {} + fn visit_i64x2_lane_select(&mut self, offset: usize) {} + fn visit_v128_any_true(&mut self, offset: usize) {} + fn visit_i8x16_all_true(&mut self, offset: usize) {} + fn visit_i8x16_bitmask(&mut self, offset: usize) {} + fn visit_i16x8_all_true(&mut self, offset: usize) {} + fn visit_i16x8_bitmask(&mut self, offset: usize) {} + fn visit_i32x4_all_true(&mut self, offset: usize) {} + fn visit_i32x4_bitmask(&mut self, offset: usize) {} + fn visit_i64x2_all_true(&mut self, offset: usize) {} + fn visit_i64x2_bitmask(&mut self, offset: usize) {} + fn visit_i8x16_shl(&mut self, offset: usize) {} + fn visit_i8x16_shr_s(&mut self, offset: usize) {} + fn visit_i8x16_shr_u(&mut self, offset: usize) {} + fn visit_i16x8_shl(&mut self, offset: usize) {} + fn visit_i16x8_shr_s(&mut self, offset: usize) {} + fn visit_i16x8_shr_u(&mut self, offset: usize) {} + fn visit_i32x4_shl(&mut self, offset: usize) {} + fn visit_i32x4_shr_s(&mut self, offset: usize) {} + fn visit_i32x4_shr_u(&mut self, offset: usize) {} + fn visit_i64x2_shl(&mut self, offset: usize) {} + fn visit_i64x2_shr_s(&mut self, offset: usize) {} + fn visit_i64x2_shr_u(&mut self, offset: usize) {} + fn visit_i8x16_swizzle(&mut self, offset: usize) {} + fn visit_i8x16_relaxed_swizzle(&mut self, offset: usize) {} + fn visit_i8x16_shuffle(&mut self, offset: usize, lanes: [SIMDLaneIndex; 16]) {} + fn visit_v128_load8_splat(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_v128_load16_splat(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_v128_load32_splat(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_v128_load32_zero(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_v128_load64_splat(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_v128_load64_zero(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_v128_load8x8_s(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_v128_load8x8_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_v128_load16x4_s(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_v128_load16x4_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_v128_load32x2_s(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_v128_load32x2_u(&mut self, offset: usize, memarg: MemoryImmediate) {} + fn visit_v128_load8_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) { + } + fn visit_v128_load16_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) { + } + fn visit_v128_load32_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) { + } + fn visit_v128_load64_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) { + } + fn visit_v128_store8_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) { + } + fn visit_v128_store16_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) { + } + fn visit_v128_store32_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) { + } + fn visit_v128_store64_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) { + } + fn visit_memory_init(&mut self, offset: usize, mem: u32, segment: u32) {} + fn visit_data_drop(&mut self, offset: usize, segment: u32) {} + fn visit_memory_copy(&mut self, offset: usize, src: u32, dst: u32) {} + fn visit_memory_fill(&mut self, offset: usize, mem: u32) {} + fn visit_table_init(&mut self, offset: usize, segment: u32, table: u32) {} + fn visit_elem_drop(&mut self, offset: usize, segment: u32) {} + fn visit_table_copy(&mut self, offset: usize, dst_table: u32, src_table: u32) {} + fn visit_table_get(&mut self, offset: usize, table: u32) {} + fn visit_table_set(&mut self, offset: usize, table: u32) {} + fn visit_table_grow(&mut self, offset: usize, table: u32) {} + fn visit_table_size(&mut self, offset: usize, table: u32) {} + fn visit_table_fill(&mut self, offset: usize, table: u32) {} + + fn visit_memory_read_pkru(&mut self, offset: usize) {} + fn visit_memory_write_pkru(&mut self, offset: usize) {} +} diff --git a/crates/wasmparser/benches/bz2.wasm b/crates/wasmparser/benches/bz2.wasm new file mode 100644 index 0000000000000000000000000000000000000000..e918e614ff9993a0a1e3d462a4c5e405155cadde GIT binary patch literal 187897 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

*~FS{oachwq{(Okx}18u4FhX}M|XOTQRn`$leB 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 @cDrVyE5YbJRyu7@vMTL6dh{$8~@l)$- zO6zCLE*(3rY|QBTSySt(0>2aM>*mc%j;^VlKBr+u)#zz8$@)mU*_n>3YNyYdJGE|h z8S^(Q(m8XIC(dWJKTGjWnNrHnO&3p4T(}wpS1>_c~Pa+RN(@O?rd2czu#y z&q}WYf1A7lka8~`oftLuoscy5bxgq3kZ-8yP|zE(Jg+!@uh%QuWG+2E;dP6ecViV^ z*XT-f$??@*QPjL2Yr+>v(LsBML8V%n%>?ZekL~LfnEpwxIGTTJUWpe=n2#5hdHtg1 z{7%hYN3&}(np|FH?pWC5^@y5>Iwj6+`-z%oVCfJw8#*;c&7BML$K-h(qh?L#MAWRW zZ;G0)<6vhrBuSb%s~{OQUnY}YVbr`K+y{sIkxs-$T;*UDl^|u}zPVHWA$eXTYMxqH z;kaUD(fq?ppl^UN(IQ3=rLs8)aC2UEh~_9nm9u%YQ+d?fzA)hx3H1sRIIP&mJCVR! z7p^pqcdBfvECX!(uY{lJ@U6m^IQ$#oiygj5WxB}Wi-mvFVB=jP ze5=FH6#kXN{}fNC9A9*`urW@_uLh^&*LDV9S8qe#tvY+q;r9x^-{JQQzt`dGgs*k@ zdf{svzESvUhd(O(cHyd&r#mOSLi6FEMlb$0&G}Fp?c<&D$5BqVrt0mm%xZgFP3cxw zZBMA$Zn4z{s%pE1)6J!fZ+X41QhDD%q;$mRJ8hx? zCcP3md-rIWR}w3a{w%;+yn)fHqvj7Jp>>NN7&WhS+T>`(QS(|Sb@DQ=I986(nNf3< zYrb!)?`$zwlDIcJRVP8pL0salByn#laaWQ!JbA}T)EVAVUN2vm0IA?zt^!@tIsfRq z=*pzJEe=GjuP+CoL$0qc14*jyt*_qzib&^I#=BWeylppY?u_Jz>($LbRf-SS+xl8d zt5Ek^hxE0Qz7FYYC4C*zX@`=&4(TwqfK<42=1-%YT+R?<8!HWK9q|#2w~g;E#rKen z4^;6z!jb0bQoI#KXEsUiMN%0pQPVsrGrZPeNMW1oTT52 z^!p|KUZmeI>GvZ2ekc82q{G+}_=&q&OuVi12PFL-D;*T+UjOKrsJW}YQDv!)tSHtJ z#X3c?mMGRKinT>tImH68c|ELpxJK|w%k)Jy66Eu*H z3%vf>C3L%sG+Yzh3t-7F^FR{BShex8*MD(UAr>6&*X zeHqd>OZqaTZmw< zMprCLiRBB$vXof9P%KM{S2QM~7*F@=lQ3tw zL0?LO#Gi@yuO$9V#D696XCnS9C;m*t!`Kq|<%&PkiT^q+{tPExdWXa>LHt&UUxN6p z62AoTTb=kNh=;Ky@XHmy#EJh`TKwrwyi^&9UyS%~Bz`gCzmfRGi2ufkUyOJdTLQma z@r#}KZ`0x%op@-~Azg=2@|%WAZ)DV*9xwMs zP>m%C^REUwBN79co(gSD4R*eGNocOsaO_w8p>v3U#8eMlOjA>4{vU0W>I3! zi#JJ!`lz9iSqG7HI7y^$T^!G!o`;^b(!7TU@m(6v|BY51mFAs>GHG0w#VexC=4}$r zxO@erkZdk9EyRC?;%_1TD}wl2h#!U)LjMFE-UYvag;a;dUcuUEGdbAH8yeM0ipAKw z$D=;=MV*hKhk|g^Wv@Hz~3qXgDO&yw#8t;`OWW3M+AG#v*fQ=QbPFO!u&Dl0FO zl|Keqd6}&IQAPPOMTsYGRK;FVb1kJ|ULqb6(t1txr#Q-}+Q^HD{F6k!h{!*wjl77M zKgIJ8&68sGBEnfkv;@8k*U{K2udDg(sg+UlB>j$RxIUg=jk5MUX=Q!4A|5MIwLgpC z6%za`f>#7-eHL*mB<@)v!IP3%8#RAx*r3{56|eBRQQCiPXi@{Z8FGILZdlZuKx7i% zn^j$WImAly2&J?=u10V4a<6x#H;fe__1+V&O0Rdqi?gO|s8EPIgAf}C!D_jgSc>bt zZf|*oi|Lk0Zy2RDw%psX(d$VDDx(JxYc&Zw(%Wu6;VV4^M$87+#2<*~kGD+@uX_+k z_Mb+e+TcxO>FM}N-mxu8|MR53%h;J-94W7OJxrY%asH4J7*?vGKO5iV4fMgvyn(3q zmC-#}6OcBN4>|&GvPI|X5}ojALxUIp>-`YyBvV)E4URT?Ju1D9inc3IMxRoYv4c%N?HTWXd~jK z#jmDTH>y@w!-}UBwi?!ru#!J>BFy*Dcae#g)|<_0i;qx9-J^}>4*H3WjuyJsE4+tZ zMb{ePs`xId*k)yUlyuR-sJ(|M{lOg3JUdI!>G0~MoGvDiXE`tKBbgoZm69XyC{*~Uqrhoh2=nLMcOBn&x4=Iwb zHHHP25c=USGnc$ytCyeAkiSD7Y#V4)XEbcV3iEY5R-q1m2F3lgiu(+T`|F^%&!D)m zt~6KR8(S&f=A<~pTA9S4LtLPZZH8)rS_W0JV^$_eBOc|cEOnBQh zdHa+@Ke7hJtjRo#y@~|fSCA<6`j4WwAp`fl$mqY`+kT?gdoQosT5s4y#`I=ySi&39 zX4jiV1sJo75JlWeUQZ zVsc2M#?kjErk>=suM7tlcw;ttWh81$!Yixvde96`%DqBo2UUhj2wzI9_>adiKv z`5X~s=WG~gV4u~~*Qr7Cd)8aHKV|jR2S+usV+~%Pdap1xGrFbBY(eNb2zPI35hqX_ z%q3+qw8o=@ygoZP0d|;PCQI06mdl8~uyci1a++7Xka(NS`^3OF{SNlj9BXS!D{HH{ z==gGVmCH%&m}rcNq|v-ppT9k$)5Uldo2O3JIM~W&+ggfjwiwNBGUcHVMud0k86gpU zDG9A8Tj>q2_O`F^hF9WuAgW0{N(+j_Lk0N<5!qeIX7$mBY0bl41ANwpDwHYV!xWFG|F#lyBg34gCb4*YGJ^D9d)W`eJ2e&^_~a%md5cFArZ7 zTW~v)T-`Z_VU)4#H5wV31d6#4c{v)^|qf0R%wZp z!i`8AO=L9Pzt+bvkiOyC6ywWEaOEh;yMh_UVVW`+tK7KHoXvQ>lJU9{B&l&5Mu&;< z%j8O0lld(}X5k?9zb|M|V=!|UP()a-lbQ$%%Dvr4|CmbiHDd`4`AijbgV?ow&=sk% zYRcBl5bQaCscg@(WgF};oKvvUD=B4eD)UA%MOAwxjpoy&#vpT!25f4wOSI1GKgsJp zi*i~?t$a*u%wEeF?TBhKDZ_P1L9<-%I@dB9!@$^RdV@yS(F|7ARMjG{&+%U01zwL6 zSQyX}tdNRd!}+rm=inU97RPx>0m{<5%J|KlXb!}s9gnV3)|<4SVVw-9n>#nPy$N%! z*TM8@$}e*JLpnEP9_W?l^@{JyNP;nU7UtPrE9tM}Uci_>EB}Z*?bxjEmB8vdi^k6A zy0KR^ZNI`RLfvHcNO%cKtx+|wdX`;eZRnLCuc%Z^1X@<9;Me~>BclSEHgWf-j7NC-Q zwig<6DTCH>uMg&ygjqSut}CDIB^@Ap$4AW#q>MTL8N3x)zvyh<>X)(Ss9Cgp zmZnK>M<(=2uS*5=J)y_Syu9eF{5)4yr>d;ZPULxoadQjpKK^!o%u#gO%B<{>=k<=q z4z44%Cy!f+RI`Qxh(!}-{c(1w`D72O?JvhAwE}#s2laT{an(`tc#leUFz{v3@rPr4>hAPmP2GEg8)2!XG((7OD2z&h> z;s1){{~E*hbb}7j{k&21+L3HL%0|^3-PeoN*>U6!Ix6Gl<8;3QCbCkrJUXAc=5li@ zU6Y~g2|95%ro=9cLmel2MWBC?&hDt={A)I6uT#CE$vM0$9Pg&@ z;YEc>nCl$xi`}Y8!KN?;PHv%@&$)?ctkK-&2AfyiU_-K&rSh^o$ja4D(CgWPicX#E z6&{9=N^{Me3YEhL-6~?sypnU6Ad=>yIkM`#-_2U}unTvNF{b}^&T{j4w+h~@g-}7d zVc9{uZ}AGtDLd5X8&MOPM+>7naySrU@*Gwp=G$(K-heV$GO!d5CM&%$YcLN+W2`>6 zDKfzdsppO8Lvv8*8BV_?hZ!Q#`Lactv*$F*fc<$l>}}s8_9`n@s^tGhv8XglyC=NP zF_tHrXEV>EN?g%>C6ghh9crn^Xs>^1)Vw*{R^syR*xRU-61y+TdVhmAzTCV%J0X*T z53$$jRH|B=IpY*&@E7LBR$^-?*`nHbZZ0zt8cPXvg!7rX>`&v8;pUmS%y%igl9|)o zSb|dgSMexFLj2VzPF??P;Kug$;G&vutvnzvP!7%2CggEUiqSY%&t(_3 zq>QMZYhO%MRTpBq-o^AJl@i2%5~+R##dt0X6%v&g${hCR;nAszc$D?bb#u44f`;p_ zUw=qo}YOU`V7njo_D$RSfQpU_>#qJ0S$IBw-?ON1Dyr5J@_n|}JrofgL zZ-|<|*RE87TwP2_9LaVDq`*m=dac%${2z;DUTUI8;r9{&Wcx2}VKGW?LS2hX$L`L` zx+kU7UF+Aq#rd~dRCBWuyEgyh(UCh-#j+0{g|JE|>~T_CWNt0i0{L;GM(`cQE5A?h z!&Y!}E5QYfqg^MbW#8)(`q1~wyVJ_s&`MrWlxgj6UeQ9bMeCq()mNCKRl4ZtY-H!D zzlmU;oJ%wPGiz^=m|q&TG4$+gPWhP?j88qI$J0n>C(Vsac7L6{f!1a&?~c5;G%$g( z^)uTVjBkNEZrGvm`hH3wtn_wXjxmppI)H-Pd4snf1erSb!0a=dUO^wduX{OD4c3ft z*q^X#F_}fLzS1k!#LY1hMz=xc{_a?}q75^>9*eD+vTKXCT_X##!w60)#~>u(?FUk6 z-Q5{X2r&YST{Gd!aaDSIw6vDJ#>!rwA)C!d581;Ty>iKJM)n>A#)_B1D=kI~d!jpK zcFXLTta#?0QCf(l+H$57*5{D03!;0(s?DEgwH}!31}sl1_1NCV!fVN zON3gC1?B59zV>RMN;VjugX z@v19A=9{8CZ)DsQVNw_s8|szJP=hp|&Sz<8e&40h8`05}gkvLuKqj8!d?*Mq9OZ zs16*mn6GwcE|mm&#tyP&$#OYgJw@KwSm!4!eFx6O%*W0`_PVGE=Z`A!I@pnkP3z&^ zNYmd5vogBB29{0pY5O*59GfshnF5|7aYeMJF6`fq_KHe15}7B+z##l8!0dQ>D+wtY z6|IOZXS5pP^*EdY=d`Qr8%VI5(06sAokwF8=Arr0Bh1~DOXo#Qh4WoQ?b2j*gfSXc zA0Qvy%{>SmM2(F8=!35v1M3p=i9xO zbs|XrC}c405uFJxYjTBYCL2iGXr*aKay6O75C#Z+l-uCvD~pDv{CZmO#=Pm{o#*x;lKJX5%mk*LzFBJhs5sH0L2jVz~_0Q8Pd*4|^TtJ|WM|02nvJpV*I zg*cip^Y{KKO($voh}ZV!eSb7GvaUq4+C_68 z>%~AvJCXFhimthUu7^0K#OY`o;lY}vV~4jdu$tJTMNa8*n%Hg5^Rd8_#`iXwI^6_g zj|}qrP@F34QL0YxA#`)AKUt;k#sx_l3Av^AS1fQU5`~6q)dIKm{ty+?(ab_)DmA@f zz6&mfn)AqVp;^gpdpMp_Rp*gb4NElL`rr##77g}+t9mY5pz#fQgryr7_ z>}B55=yx#=VICFMaXFkby^cN&i?zl|on;sh{XL#^@yh4~c4E$_<6|-Zs7r#>&u?QE z&;?QRx1M=kNt|_Twap$|9d3J}r!~!DoRi9C&7$mabz1IqVc+X?uj4{59=jU{#_$@c zYv$vgYNlFy*3m0}OP zg9`y)TJiE^ru~|t>UyO&WTLm*5tK@IGPsnwY4SW4X_PLEm_qfYiW_Gj?rY^XEW8c z89LsDHFlEzuqXLCpVFgw{;5}4zHTUm7gugfZA>K1NBV>Ye8m#fNx#i$ibShc+$! z^SpvMyD=q<;F|n6yVjGs>|ct`$dMoHTtyAMmTP%7l*6ji>4Qh)~5;mW47Mjm+ zjbLXEQ@!-G$xMaIC5$Y*`fFy}_0jwZCCU8#F{VY&I}Mux1}%1166S`P_KwW6y*Zqd z|07FYpC(J=x~_vZSR2ja>DJ_s$+^PoVx%5lG_#s8W>asit|XQum>W7U;w&O{C1w#P z${1uB;GQKhMKKiP8)h!I?%s)L{$Z(TIn|V#s)JJGHWS@$@_%0Vii{GW=>NiEwV%d5 z4P54lU(>ML%+j*OUN3WZ2NtjYm}ZA}S9UJJD=4ZmZ#xc!1UaU(zUYnF&+M42ucyCM z+nt-QdRNks`_bpRt-?k&vzcaMzGTQn$uwupw3_dAeXQPUUZ^fJ*Rg+Ix&@{a;IOJ} zNwap$wCH0#GS609%i=0j7SwtU2%2ZAt-gF)ACCBVMeFP|C!0VqTK`kkoH{T!BeOqU zy@-xb99=@?>dY4^(xarYJBA*FNx|a`8nWn@&63V>hXxjC)vOFTRMLmR1?{w2n&?^# zI}z}tC=c|}PPW}*I)VA#a3w|K$lcZSeo@ge4Tr7Q2H_%D(RY1&U(?F|4bTSeZCJ3_j>X-6qFMJ)pVJM*&wH->>$4K(6-L=^aV{^Kh2K#+nSGC#3`cr71Z1wF zLur(#Ql89Do)#-T5t z$UORKl^seh?8_`L+Uszx*Xt^;BY&4|>o1FdDm%ts*0(a+V&1N@OQy^FR@0EG&0EfS zMPHe6t4)h@UKu#wbk5~{X?lOJath(~eOXdJUzIQ>!C&)4* z#jVhat`P5&5UI4=@Q~uytU#DD!->Meh*ZkBZ8{G8f+L{%m7w1 z^^8I@G>z(L#q+RJ>5uhY?v>{6-QDXLYWGY z0Xd4(h{tJoG|B||-{e6eh?%B`O{}kB%}nh|$J;K!QbniR3R#HtWuV`#`hS>5kLVoQ zaHY4qj!Kb(J-rDdDNGa|<~Z_EM(LJ14@||_lFISe6OVFlyZ=rPTElpnhnDz*DOrx$ zQq=#WJbFZjw=UTowo$S5?^H%+R9OT;4C1q}ig`74w&& zR|klnW$X-wZq6>q#uDcowbpO_qE9joch^zAO0!`Gh8V`-H4LxXxWhnC`|2NE57ipu zwHdz?%`CsHgu!sRHy)S(V4U^w2K(>uT}c{NDh;cYhLxmYB`N#CzUB#KpCY`gUn4X7 z4X0|}Vo_agCphdjkM-N)^>~&km63Rds5wm+c5Y*K>&;Y*87hH;3H-19P%Lho!9Fyz zE%%RlP;?wNb;j^NQArGsFHyi;a6!HfF#K@_6CBo&*YK60B4Vy4IQqih`>pi4Kj#%K zKx1e2w=7avq^MtwB+~RY#IO)=qrSsI(c8MOmhGRK^y?SsYbRvYaS8!e8E z)eM3${j5QHmeoO<2f=!0n;bz8>tJ@HhkiKSnjSCcuZvz7B>xdcf}*@)<_2UX!qTEF zpX*(wDAn!B{|z%6IcsSy;N*hL=RMHCWymo1pIm|U$;Q8|fjz*xjLaOiEq^$@h45xM zcOyEO)hFxF_cmimXH0$V5d-h*)2r!P=4uM0Cp`=U6*gaP-n~XHY{s!HY(rjZ0WB-( zqel08*yCY6s+_zw-ENIsLrxfC%&R{{oGS-}Ds(8+mcy-CW&YF7kU@e->H!pc>H!pc> zH!penNO`-feR*p)FL`S>FL`S>FL`S>FL~Rnysd3t-rCJe-rCJe-rCJe-rCJe-ab~| zn%kGRcJq?AcJq?AcJq?AcJq?APn5Sc?aN!cdC6P5dC6P5dC6P5dCA)r_fYqD=O{*t$L^OCoA^OCnumABQ?wS(~8X<(deH!pc>H!pc>H!pc>H!pen zr}B13`|{RqUh>v%Uh>v%Uh>v%Uh?*t@^*Xs^44x%^44x%^44x%@)q)r%4uh9D7NJ9 zMYctYWb8dcdk2_q%dNgd8-2Nd8R}eKl#@nRP0u)?z{<>>Q+3Ow@YtH&z-@B3u~v1? zyp1*VVI5_F(j$IR)Lc7dgL#Rss}ym^K}VxYD~vyd4PsQ`zb6vbYsWIPdcu*>I*|3Kz%BCy7chZOfT0i3G>uf=E6k z5}iHfpwI6EuYab!euo!@r~qe+ninc1kl#zrhvt^~Wzf zz7DY8>gT~nr{{@v;U^yT zRc~_*B{eEO7~Sz|ZiIF)uh&=asZ6xpKXL4p<4&&($=^;bBx(L|G-n2IC%{;*fmK+HCC&RousbB`xiZYr z48A^fG^Yg=l=8^o{WzO?RutMftm-EI9sols(1JGK7uJ#a^D-jkzI_Ltz*FiQj0s#m8B+_wR9>k1MOIDR;R3 zH6+1mlGC0NH^?g)Lv&r}&#j_6ZRj?l^NOhJtw&ii*BL`oF+RBM7|$G<6XOM8eAQt! z>m%*vS}Le#oFm-NQB-7O)sXz56wxzBa|MQti6PqaWq(`7mVGdwara#(*jeF>b*l?b zf?_j+TutsdZ}Jw47%W4qj0e8u6|e!gFXi5H^ajaZMtSz1oR$*Z5p&Z3_L3VY9$vP1 zRoFTrx4q7WX=BkQ>k`f*>Repw(q({HO}FX1NNs+H6F43IuRQi<%#u^saRTRDG6FIL zoxcr1B=3#EGy(q@-3@+YFr6;Ox!Ggvi17JfYI}@b3S%cK#+M@n7xGB0} zd2{}bCFb;FFiDty4d#CL>Bp3Tl(W@;`Z102;=Lt!%W`PG8Ju9LrQ>27y#$s73Tpy| zwdfc=CW4i12&wsxqg&K~J|C>R_7p4QmED2n$ah3(OYpX7`yiFJw=&aq9%&;ziZPv@cyyds z^kdVNg|=B2p~dSE%t~)Wf>X}2t5LMy+ETX%T?X=PG6tv-$&wg>z8yd*;jWAsL(^fF8GHNZ7zjX_OA zH3sn^hU_tjbd9m&e4k45?ore?>AaMFquBtjcLJ}=(q3=NixzkJP^#vwqu5sK8Z}oA zWd;A{QAv%VR}D>#p?36JVPk&DD|*pNWsZ4NBB--F0;$X~j~r#^m^+6iViOsSkE)QQ z$A(f!w=qNwV0kn&QNQq}(@v;6@wDSlX9xFA7ujR!$n>)c=5NE>9BPSeEEbGObYk=B z@GW4=RfVr}rrtH;t0vhdwPhG)isA`gcM@^dWSwR=Ukz)bN-FiSkFNB7)p#LCF9z^+ z(m`)~!}#pczr5m?ydTqOPn&ET#$u%EHhb9y^;FvG0LBTb&wM?}PGV<_AX{Hgv^$|o zhtvEU*qdduL&pP&_cKyS+S>J*3@Ty}4g4BzarTeq?^TlINCyI_l>X-I;T1`pk^5{C zH?we+Tglj^f5*2j_{z$FyKJI9okVKR8O}EQ46kSsF_UBtpp=;{lQ@jYaePu(Y@VCG zg{Ib?&uzrb^)5AIOBDNNmzZTiVm8~vEF&?S$tH<8FC#IP=0hdsf;JNK50{vWY+|1N z0g1UWGcoVE#9SOC<~^I3i%HCTE-{xVF)Lij(D;>@%UUJIyiFzk!0Nd*GYu^+4Oawd zXt8Oyf;6m3t%y5_cThBcysd~g6z?G8 z2l2i^ymIlS8{*}3)K$bgXoc5xEhaa1-7C%Old5$N>9XPU^S9w)G4usrAkYVcmQJ=; z!#*3n3Ds3z7HE8IuQ-=sMXqvlE+YvIaSMt^zf`aI{ZZ8Y zKha@Y_ln;gWqZZvL>NbJTzV9rp0tsuu`hLT;9=ufYUB8VIF`CNzRZY&PfRL~uiJ>@ z3>U}0f;biv$2X}s7P~m`uyHK5aePA@i(MSwDvneeK232f!gSv{AB%{C9i+x#6!*82 zH-M<5l!g?`7eUeRLwo1%Evm_9+6)|%0 z{Y%8q-p)YGz|8jcHI0fkMgveAqfH&k#~totDjm-}N`RBf>rdlf{ZhV@RLS|i2*%OL znu5*pVcM9|-j$hGcF@l-;!Nhi7fqTd;CdadVOZ6Naorj&%;A%{O2Kq6jA@A5Nd01W zd4uY`{tLbCTp|=dYZjEiVfiEYj7EdkKlV?rA5+fL_@k5DHcShqq<%!;3omK~U~A<6ds(Bzfi6};{4&D|7xF>?h&Zp1uDFr?f!Ovmq}zTAfg zmGscC76cIRA-E%8EL_0#DJHIz+bpexvxxJHX>oDQc&iDtk=Rz-AR8%xbdWn-kVn%& zMxn#R>o~eJS$74^6T|o#5d#mOZoHF;@Gp}q%#+Ca3shUUZ1S18*JlRN$GXEnG-(UNzaS9p>=wpR?5<{riHU{(xwyBOBl z7_RvNF}#wBL3N)W#IQy&Y)Hjm?)>4C-y2r2u6V4nGa4VmVJ6cFgkp2$^!%}WUZ*G)H#`+HmLURbkmcXlBTEUmFkw^n!eD&nxuv8s*egZc%`vktc4oQ zMU!MrN%vj$kUu8yhqmTyVN_{(tn^(=)&k}sFyCjaNTKDIuA=lY?>E8!HdoEN)FcX!;*zM$E+Lke9s|bo;$*hUC*=bm$rVLTQt9j zvnzd`3hJVJoMCAB_bzg{n~aXiEc{pOrm=NiKaUUx2X>}cLUag$fd%xtdYW~jOG2>XGxb)z_eYyP>A9cZo2 z7|ib)nmqorUu!jH>XY>+*KxYyVyd8ZbJ0@VTzkYOE%sj@sY~u*HQjh}o7MDhYWDW_ z=UaSwvdH}TWLjlI+VB>Xf>qc+bd0z1(ujp#ei}mz& zUFeM{^>!WY?L5&NafH`JeK`;oyz4d^KgV_%y%NH@M*@Ur`dppS-{snbW2fqY`xdvbbMBGX?KL# zh!2)ohF;Q8U~WIP(d%TMjM(tK2>V>5PW zzI8oTs?uk_k_CYSPM8|Pdy|a4zbn-TRGPg$+yvGg<5I`V5fF1WU%96Lcjebk3e7E~ zD-6bnzpOODp@@%u#W!>$Gc7XZ3^xVzbCG6A*F3LNe1Ghd&Gdq`!Fa70U$TtX<}m&(gYnN|e9kidIfwD748~Pre8w`a%3*vg zgYhq7e9|)hC5LfC2IK8weAF`Dp2PT12ICqruD6V9av1Lm8EF^y(ug|G_oB4j&e4-> z%PQj247v=Ju=TCeQL66FsE`tR_q>%D1Rg|a5t>?>ZGzTG=n<$R3#Hdo3;d zYAgG-ZOG=TOjwt1NVacfzmX%G+j$}1TWQ&sTiI`ILw5Icn0F-mQY-tN9N8slz7Nu} zFSN2h*oJHlo`&i9P_oarvOmm`-8tZ6nEZ@(-Nl@=fkA4XwW@Ey8IxS0BZ|-3#=QKvq_*&!0KDbmFDlq*unj3JoVKcz8k|QpvPm) z*Z91cWlyDfm2eEs*S2OUWV=YGdk69(B{KiN=@p)C1H3>0t&9l}*V05wnZ2^bXNUbR zSI_7h-l#L|wiUM+Nb%F87=7c`!LbTkKKg~?4v`xE=Kd(6eiMUo*X@W-rV^$bE@h}>yo4A)Jz*at)XU4vZl5^5~&sSGRwov;(l?|^eyuY=ZFhbYe#xJ zPGsp;?wLw`;9*>)XO>&#WjaxGh#dF-a)#zM%$b+08K0A*?)oHZ?5L>Wlp-@LN5VOW zs=0i$SIopcy-B_aUDe9)J*FvYSdR9X$f~*0uvVqLjN~x+0Oz)wQ@B+=5pyIK1~U>J z15|bep>fVTcI3!p52E2xKUy~fH3l-4W+*VSyI@c|)cz#lXzd{pcMrZUz-`7h_ztn( zt?kR=*7V^FyqU@TVft{>$IPVZm_C)Zm=Cta{6M>kSgO}R z_lGwB3r#Tlmo_sSB)=(1{kaCI-IDP&mc?YRf^y!ClI55KI`B}w@GF%ix@XiJYZtG> z61KTrWYnuU&GK&@rv9C!)2cuk81nd?)zlc#s({jC;F}R$q>Y`dAwhE*J@tIn7qq>P zA{aT(JC)ALyt9Qxh;EVe!F1Az<2KA&H?lP7G!aa@fn(WWW;ctWhN(#FIlhdCZ5JCh zOFJ%q^0{)px5vulSg-qD_{nmz+X}B>LDU?g`!r_HYKC35pSjt}2dM45WD@2_gov7Q z8Zf&b`&)C%-V7=18X8VAblVw8)=I>*$Ni(i=uoeFgQTha8Eiie#4#Vf)u2-z4PJM{@1t~L4xXq(4P6c2jW-E>$h?N6@RRhX_Q2Xm?JpXV zk=jYbF}*%gUsboTW_s0+Ya?^!k=-m&KRt3@-Hfz!D{Q}c^X5bj-(PZ5y!Er@)wzhr z?hxatoOzT@$~CJ7mt`ii0k<&60G7!wrwyRr z!>)=Imt9vibuI~kYl;F*pOxX5Q&k(8M!4C(np!(! z-rSn{su_{GpC2~wC-Wk8haEDnJ~FL-zlQ2+UI*1IM4ng=tvRV`?3gjLBlY^x?gOf% z2iH~A*GHx|)Ya`Lj-Stq(Bh`etFK9(7@1dBGxLyST_h=Sv&T^2Csik>PK(r9VN)6u z<#g*~|L#9;{)v%fGBRfl)i7tycoI9Wu4;yryZ^8D51jkYn>&pkHJ>4$=~L%SZ64(Jyn0EO@*tzY7R>Nyt))}aI!k0;+j)4 zwp+P)> z`$xan&vDHZ69s9-T8GNdy3|AtJ&`(9jIJ0Do=}`Am}Kd}bb8Q>$#dbR1+e@9_O>F)0l*4^crJaHwsGHMW1$)Xu0nflfT{$CUSs z6R7P-ErnY%gZ@!dd#JkFd>Vyq1Ca#{Q)kporQ2sT4BLVt(;8;XtV%}e8ft56YG?kU zZblVhYGxiVueK^Oot8qBND}s=+8K<)wGDHBDdDs!8f5*n$n>$1*^z|{BeNnWRn^Ul z%&K98h)kR2!tu7XGOMPVpS53b#MC*FspA^v&rpX_GOehc2ytkVko=he(37UmK8T9Z z`=?a6-UmeL=SOBl<|H9B)beNM|5KfncDHR@(NRKCvgI|68^=x4z3G<5q!iaqm(*6Q zSgoY0mSVSQ&zXZ|K)@sxV{>1&TZp#Vtc)`?oo0PrdbofbW-7**ZRIE|UzOHiQJjs8m<^wQq{2*% zRRH&M@$!0^LF{D8fbj9H@A4MpwY~nmb5v`0C{j+PNK{E^o21P zH-d2{X+GR@tV0NufW78SLM8)5S}0;0zNBGl%E^FS@GL#;1b!x)E}pyK#Zn2pCx@qd zeDPk6oX%~hnxQ0O))*g?2IXl2tx86-J z0uyFV4!1NDZNZHhOa1gf2`__S44ki&cOFJ7y+wLJacn$V~R;sVy)*pk~eHk8_D*uWj4Ag z-vkb_Wz1~jD}VuELwT?=iZdbB`Z~a=kjfk&#R5iW@CE#7-;Aw5Syd@$($XhNQZQy} z3&|)-hDxrsLL8PCTdcsR__u`t3iwAs!&Cgbd?N^R%)2aD-YOSLtTX^Z*yfIgZ8KZy zil!C22OTgPdOX$Q0H=&%RgR&JKu=N3wV(w5w#5Q0!fr9U;f{@nu_V|ZDviX9-BYxY zT@?jg0E(<)bb<9m?JN|-sL*^12pv}E3Jld0hsl-HBVIWLE^-fZb36T3marJQyO_K* z++*K};4JJ0ilSjSYS>gr){Z%Zl%wY#$Q$Yb1<}zmM5BHL&QoN1_$ni5BXbrMPNQk& za;8x-;MOCNj|$QRs$@ngoxM;ZLmCA#u;ODNy2DD2%2UIkiX!y_p&!nkshJwVfq-o* zSS(Y(jKCHdL}5=tKi7RV3BVAwz7X3}dx-dSL&{SdNbjrUkrbb(u<~LZcn-R9=Ko(HIY1;mRJHr?5;2- zc@hQw+X}kDVhuw*0wXp#$8>pKWpK2#$~}U=ev*A=5w>JL#;}w^=m(>8!t}?&RZ_LZ zCLlwb6gdQCb5vq`Tr3W^*eQn0s61ZAtv6%-0ajnCsIQ`)^7^XisiLpGmRxrERP4g1 zjUUZ(_T?$;u_L{>{<#33T2c_%d{>hgdj0#VtoQ^sv@_wMX^5o3r6hzHLqV4iWWJ7J z7wzC5O7ZJR^q0Tv;>KxzGFYDDtF5#A?cgT+ql20w?noW(;~$xi1H=@F(h$s${Eka| z6plPN{|AP#Cp{OlOB=)I_z^JSa&HI0(QhyWbNPO>y#gX;6**6=aXLZ24MATEqJ)#p z=d!R9s6heL$nynxeGWD`A_ja|LWlgOpr-2Vb+>qXl7BIiYh906v878>ZTG23tf@q* zFBtcNyLI6`X#HPyp@IEt?)&F{4fyXiUv_;C2R*vedpl)%Z>QEs3z+?no=_p_xr<~u zSBb7Hc8TPceu;R{g>drHc2>!~9dztrJYx9Eoe*sT5Y^54}BtqCxVEZW0)MpUkCxhC;Kri^*{#wA;T9pAiG_Y5cv z9lvv{Ei+X_j-qk$w0>u`+J^?_3%hT(ZGqp6*qAQ?37}3hlWg9u`!OYy`>3TbZ zH%be0xmg7S5z<`bI|Wy<)%25UR9snDePPV-YSRHmO7A zOu$pqPwZ=v19(`Eh~tqgPIBBEU2CnI*Ul$WZ{4yP%hJL3H*VWxX*I!m`>G6RGOSx0 z#4J*YZ(doB<+YIV^^1<$GHSPNT9ox5UX-EB_!>|8gmuKdw_oGdJ zWS@TA;YvQ}`XkA$sDw|3|Dn|vLfp|l( z85}?OAHMU74gTdy1H=+{{-gI6Mr3Iw=jqLy#oZdg0vNsp&XJ@%hUjes1hZ52*9E}a z9X9WDSo!f*oluU`$iKJlxX7}9)hXP3cz@lm;&}St97uhF^pg&q_SfAk#}@{_+0c4K zeE;@}1}6O|Map7^zq<^x1S9+!;tfBYw{YO^FKMKw;sFow7|7Gvqpp3}T@R3#6rXW; zowhvgux4+QzmhO1|GX5B<~XoR`oosJ1DUz`;|5H{RQcdtMtbe16@JO$ zDU~j&ER%ES!}&~NprcKMx56pQ>7U@k_$D5K$vcj_ScG3?f8M~INA6F%v57sLar2Ht zk5hI){TEUn=Fj9FXV0xQ|AG%5c_q%#i@$a!aQWE%a%1A^sGy0W> n)c=i5W(<`xFl%q_K6s$6kTY@cX#5Y|=^C~ZtHTgpy2UBINm@>bH2Z4?fuR> zlS!IF%K4v6`|iEhUh7%Ude*a^+q!J;rfs+Rp6B_W39s7dPy5sScpHOh_rqg2J+0IV z7rUw2jgq1w#l7+@r{_|=jh?r$$mwmYyCPQHqhPIgHn6+-=k=1jjmFM2EArsA@#BN7A9>A5~V0xE+cG|Ne8(9Dnx=UbHg;0UCNYvo!3BI*dwd^v| za#7x0s(q)`zSE`iKsvuWc@gXjTa_Q*boRJLuuY3p_`c2D7^+h6I$OJ94_wp(x9 zcKc0tZoB1VpH@)^*^;f;}#+x_av2By*ohC<(9NRW+n)050nhXN*+O4;4 z-{jR!lVfPp?K^JWddKZIZoBorZQ6F@t2b@;!qa4p%dBV0B$T#py6Kgtt*~+D);n&# zanoJ5Zuk7tR5WnY)>m&k3xw*H?@ZVXK);)(ZrpzBZJVrVPYXX-d4DAin_82(UYu;Dc?Nz?iTLEw2yqBsmAZ|Tx2S7%`-VjTLO?*-BKHNB|edA#y*@*Oi)f)_>YQ<}K!SY(O zS{bcYYW5#D_3~Gk3zCmD`8`KwNn1o$L%f(E1p+rR-&Q68>x((A9=N* z^C}guGE@yBCGZpkZLeCbw)m@8+I9QaY;kF}7f&8+1%s`M2R*!CaK&)YXbk!wsTS+8 z_YkZc9*e5{RHIfSXf>N&9LJ(k5D(A;z8?`No@RL!HQ zK~(ea^uH2(C8$(=ejH22jW^zU z`zvqVy6NWaH@@mMx8J<|R)+NUn|^%rCV1txn{K_`Ye%ozx@nVlPo;XJ6G3CijW=%E zy7l%uZe)zyqypZG>Z@M0`8C^a@%H)E+iu!Sx_5V_LH3)cUV77xP2NW;Eqi#$rfu8r z*t*GksM56O+_E07)VFQgzTuXwn_laEw9>rs##i37{iYj{aG~G$HawgA@t1?A|9#Y2 zb@3(7xO5_a{tsWXX6@Q_*Ij?Z3vPJfi`>(TuY2hY8*X^nkG%X9`u~nC2n+sy?rWcO z^>eP?wRZRY{@eVY@qgBTyZ;XVo&LN0pYz}2A0+L){`>s*`yU|fgWUbRf5`tW|9AX* zD$~CcelGl}=>F(|=$+BKqxVMdk3JY3iar#5Bsv`ZLiCH#Z-$=^e=q#+;h%?J48Iiq zMfg9$KMDUbJQn^{_$%SxgkKH+SNIR%KZa|+5&lzncXUs5Z?rFZL-fYzzGzRhH~Q7! zW5NFDC!#k;PyeF-MgRB1KM4OYJQ{vJ{G;%X!!H2oPs2Y89}B z{}=s#4*!+swQIi_{yR_q5uUK8llJsQA7Eed|HA)E-5m4(%KtL3zvBO`|G)iz@xRI6 zfB294dxCwz8-p+UZwcNS{A}>{;GO*aT=1UY{lN!=L!^H=I2?RD_~qbNf=>jW3_eB5 zuLrZiXM)cLza2ap{BH1j0l@z-I2wFD_@m$p!Jh{IJ$Os>Gts-E4@V!3-WUD6TJ(p( zSA(wwe;fQ=@DIW9;H}ZyqxVD)MMt6!L=Q$Ei+(9O5$Jb@7VHW4gnRAp-f-={aNpud zZwTK|;ae#FK=>|xe?I&$zaI%d%I`0PN5bdp^0DywPk%J}+vtn_-|_$d zivBVBjp*ybcY698(M;t;^v@)pjJ_TH3)jb^Z$RfBLDQe{7XHU zaZB6Nee#v)nzonh_w(l^2P>BH)hLdCZnP3l2fKq^DDT%_=;g=#sVun2ON0EF*UkNW z*30Y30FU41v7XN)`AlHX5BS}DCgsTz5=u;ZSA?(7<;3ubI9x}WnR-5!3}#-6u=n!q zU4Hq0W#(TV9P?BDRs~V+cP|ejG9LrrgYWi}ulkvvH}#HED~Cd_69&_1u!_e7br1*l;(!1H1+XTDMskeTCO*M;aw>sI;4U z(Q=sUw#b+a0Yk`Inw9&K$~`u(+^EVu=J(3gli|K%o)!CoiXBz4JlNi=vEH$YqE1DH zy-rmquL_Pr^v|ilf&2D0QeIDFKJ>n*>>5xwN+>1wR9vOS%`r>yA#O{=1^0opz3W$h*yG=( z-~avm{hgs;!e|03h=y6^TI>Iz9}2y+n)-QN+|=^p)ZTj;?A*x1*JO40EQ|6P{sk{; zN5ORN(a1{5`$`_XCTpdwG`e;?KgmBotx&{ny=%uajhhwFxF}oYHr$^4ZWL#gw9aie ztEX0fBllkjHULc<$pa3sSq;3s{H|^ad@rq;{Pi(XthojwhGT;iCHV@>2#IGPt(y<{hVKOM zx*p&g<^VrbYQYbbHwVg_{pHPeF(OE8wkt+j7ZWWSjFT@%UY!4CJz2`-@i@P)m0zC! zc_Vpuh35~n^n69{`SbRCW%=A+HhFUe;q~CZFoq?{_S#Kymlyv*B?t)tVHh4AnaUz+ zg-+645J;+nk!?j%#@}YybxAOxKY+BlsACfY(i9Y&GkM52Mvl>5j&_)T<7u5B_d7ma z6*1DSY?ncQ{*E-*mjCrz-+ipQIfX5$mP*B-etz7*H$`wM zBZF~qI)1({@axlXb262MFmssS_p^R-W2XYghImUd$e^4$*V8K@ZoR4p6CY82gnmrd zjAIM&daQ#PhX+ANO-mk{id(5(M1^U@mi|o$PnYgZkf(YDSWEqa$sW{ufOY+LrWK*10l8v-Efkw(1 ze=PKC(>5@vn;N1lkRg})FR~HqV^amWMq3N@4n?+i^VXeH$p6x^RE2SbL-pO~#p#gQxbqISq_YcrO1 zr>^!^Obv(Fp$;RTOAjL;`m$~6R;Js5ENOL3J7CO)lKf!~)78@uCzY|G0Y;)aLE^+z zg?W^ASGV4C1p-$9U}h~*wO)!=RAJ`5QO=}?BqJHpU`<;Nqp*{M=-DXqrEx4nXetHQ zBn@m_hV#TYKwTAb9VB3-rO-eSCQ!lnT?1ilI@nc_w|*orK6YIYOwdJxTO@6LnZ-V` zVE5#S5j?mczjI4gk0!thZ^Xn`%?#ugk}eXB(l!?2aT!G|ZjPx>g6%jsVSX^^cIiN< zzr~)9`CS>yyg?1672V&TH4kL*oXs5f+sqY;%5}OcZT4*DirLJCnc-|^4EE??&}pSY zEa?o)L+q#!8vwD{GaxqGLrgyLxkhZj5KB9Q^AI~C#0Ej^;297**hB2dQ-Ii@A-1}c z%tP#e5KBO8ra+AGR(54gU8(1p9%2VTtoDRm$*4W0D{H5ArJq*2xYGl;9qFKaAUakq z$R>H&lQVbUvv>c2gR?W!#ECAPET4RyUU=emFcya<62bLr%^MD2=B##2TaGHKHrUY# z)Ks2YFKElFjJ9;5NwHXRVtDc%uB%U+@54#;6GO&FRWW#eAm}>QPrVaEX)6y-e8dOG zkD{Tu<7!p6CienhRxzxP3Px25232pPA0uOJJHRl=_cik0Xyjk_N@FVj@`41av=LNw zHRIta3IO&pwxv}OkQl6{w}J_^<$BXSb<@ILFp=|Cv5C;)Q5}nE1PrB}Te3!%*3*cN zM(*x~tJUY8RD)^7keV+kl0s03DG~X7 zq*6RZeOS;*VTyCsd5g=3cG`Yo`7lG+fuRIv%`l{EF47jF3o&crL(d8uXvZOG#{+e9 zS)6txd(CvC#7WyXRf+U4O^LG@O_bUadSIb+T8tGbT`!GoNH$^n25C*m)!3}0%yqG% zJLVdgxIJFO!d95)SdGC7J!O#0)J=ufMNK^)tGQl|^5eB`T6aWkAIJvgROmpz3at}A zbR(kOQ=xSm5g6QEgoG1M5t4SM-Wf68OFB#DA$C-VEdjCFGaxqGL+t2NfY=g5AaWO) z5Z&wzk2%^M5sIcv3l!yI6|}30c6vV8L-7bGR-ce|b0NDq+PRS3VzhJ0H0cb@qul`^ zHU#Zv&VblV53vL15-~p=q1#N8y8d;VbR->_H&U{Z`MNY)($l6*JPChm8ul}-LA)%6234NVA^VrX;JTmv2X^aoii5Z2=9!A#R;#`w2<&eg_sCGdj`a2 zdx#x<3J@DIymMlJ0k29SUy-_C;mKzUwhac0lRa}ufv78JUS1t143+6{CWn& zW_pMnIG2dYak_?J!4BDW^8!|#AbVl9eoNAI}=+9J7dcNyG7Zuhusmd`yR2S z5Hq$s17b5h#15QG#Lki}R~uW_&&-yD%N$!0@I5VChCQ|nzh`VI#EdP^fY@vgv7=7` zVrODYVP|YvV7Dk+_OLqwcHbkm6k^7fXFzPGhuDF0iP%}PrM#g=-Z(Q`5;Spasp!S& zlz7l%OSyDUXw;t*+fs-bTb=>2*&bp?p8~|r#FoO&*s{QGQMT-1hx7ZrVoM=rYb(HW$VmrNm$gerB?f#jxCG$D1Q1}eDtYyd4!m;Cq~}sc_^|fK|bfF5oub313|>Wa>~`EZkPaRHK}j z>bVZK4Hv<-`3`teFe4L$k}Z8mMTGJc1uVoPG1YU1k)Qem0KII~u1U7^1nYhMpI>TLNU@K&bFQqoU>w`>u3D(?qjGBi9ARjReoB}xo!HdgV`sf=~n)T~e(r4RZJL)}q%COYoxmAZJ4J(e`G;W?qv3+|0>=gT zq`)~3Ew~u26Gltgu?U?LYe&&93t(1MkufRe zo=_Wg<`@R!{5?%g|LybhUun9vR*x)9a1(@mIot%{T*9XYgWB}q>wA+EZsI=DLRWvm znGmC>gf~rX-;%wHZXbe?r*>0_IOl9Gt!*J#inhc0&1Y_bg=*nI|dLP z7t)Jm2aWYrWIc|IeW7(}s#jDwz=d8ObG__3THPjq#~9~5Q2orKzAD+IuOu z=1TVWxRoq=yszXC8q3u=+h4N3->qcP?|mgl5sR)Qt2E~7?C*UmS@eEi$t4IwSMp$g z$$lQNk_8X+m0XILb0t}TF;{0lCs@gX6Z%RnOOvAHOn=FKez1}SKlGJM=zj?>m_fp; zmbPqFL8`TWjm^xIVuBzE(&Y%|F;72!mlY6PL;VEZ6Dxh)RP+<^6zHa=pDIrwf@4Sp z`LTjrLp`{H+*I`B3UX7^lPg##!+u3T8w;`CZwIi}f?5Vu3qMv1SFNlmYT>4$CszwM zH9fgn29a14 zh&h3DDwOs@^u8mqdz$eyHSR`&cHhVdH#Ls>{*r0ypY-!@73%w*So*v#;jIf39$k=d zUn8uu&R|gM432t>uQOOgmG`YPSlU})(9i(wXn_GcSNN^jGJ_f;x16+%ZMIxXT&lc_ z=!7_uRYK7vCE_IGVptf<#4S7nVXHZy)EtjMFyIaaf=LEy+sCY zonBSMWI2(oB+{hb1S(%BCAJ!F4kfugny=I1Bix=jloVLU>oFw26R+o-;o~FquzcVk z!%VZ|LZH|}RqSywuK<;3*CaCzT;T0sI?}Q<8?x(aG$jV+f;@{E)XqDaD7>!q%)6gj zZp>hA%$D2rPHeAJ^T_jA=pC(e0;*r;(75%fw7HF!179vWQDZ;B36dwb&^cJ#D8I98=PCIIPUB=0?VKl#H9&l{GPGR8@saU7 zBs!eNnXq;&Qcli<^}!9zBeC5k<-yx5lY{3FIm~lt zF9XQIL%>T+5Z+d@rV=XlHp27bA=2AGZ)>a{C81_-s~8MCRP{ELM?}3F4T+SEBC0v9 z^(sy4u0HuhWmULL$`+;ZTm@;%!A{!_>l>%{v%YbA$@&9xtWVU2h04pd4rn3&*XQ^jKY;EF;Q2ZJj|={1b7MKc;Ctm` z+qLmOiU8Ov4EBOS@ZG~67wmC^yQq(U@sUQ-#zS9uv3Nsh9ZWAv${vH29wR{pz}YgX@^kfBHG`jF0_3B zNZ@(JVlhdVx>$j+Q}sBSpVU({_&gs?sHN!zry3?Mb+MY35sE!;kph;wSb^^dHM~Yq zlpW)aq6AvH+2EWX^Xq0Pe9r6lW3UVQ67XZ@C*a4-OL&$aOl!AXz)rMsjPO97Z7XIt~qwDwd|+~4pd+Zrp`g|u#s%5 z6nmgn4`GvIjB_vp`v`REfe52R`yYv-A^e`v#!Z(F}oc6K?(WUIDb z;TCDv0?{sQkE*dx6PP?*#U`m*<`-MV(yDf;u^+;_%Jaaa#x^Vgx`chP-a0nzYYSI_ z7l9K?pT2>*mC^QRQQFXDM;OSKEz;8Sxss`GSt4x}Yo$b9b##Mv*QJekneR_0t>h;w z9WQxLC7GdI@)K;!eE|edefAo50$S{GlW9vg+tsv*5e36LUwcux=nb!DT zG;>IV5R0o`KD)<{|JoPSAotdCSjvR{(!lmIa=3x6etyztlMK*RVH&Y9t_M&14P8l< zQ9U6?#;5|GVjx)&gFwYpA~)JW%-OtC-)wtEMU*t$#;)<{ZFqPmPyEMgyIXSY^|{Lh zv?D`4->J$%_PS7kq3BTa)o`n6jW}nJ?Wsj`4LxONi}#xXPx!Dcky73Z+I}#R6QQ=A z^xVF;nQ3Z$BxDDk_=0SM+CL+FujYln^(v2Qc&hHmXZ6HM1ylxu9SL8Q>&46j`DVkl z;4vO)*wIe@fs7MZ)ptzYiGacK{DL^NB8-JE=fTqRa2O%XTe=lR6%Se{YzX-eWti z2pAl{dha8^iQ{htekj3kRA;I%1}fUA`Z>1d!_AfaAbW+qd=E|1A4@r?TK5YN84v6tC@vh4~4P8YYZrlRe$e29c z(y1{dD6`u2*xrN|^0jSlZUE{pc$YD3H zR)0WfKYm~+7^LfqSQKJevW{)Sh@&gIoh4kZ?AkFTelQVE1QX~LZ=D;(^d>RKsp}xC zc5=nQ&+iq{(Z>B)VG6JB+lHk z}yy$+OEFe4I%yeLiVnaFm9chocu7>f@O)@5r;1AR*WbPRG8Z-n@{2Tv5Jb#jLM#B3G=QC~ zj4-$UQSTIOP_6=f3#`&R;)6jU?B$P4ck>^*zAbw~e37+PQg7hOHf&ahA+Orp&Hu37 zHFif0<+dNS;Q0|vztykdkS~^_$l769l)|{BbrSN(!73Mr9EvufHen@E86jFgvr{v< z&|%lsyJ7W50}V&TR)#OX+h)sd~%F!bUnfdJ^+;tXKm7Ak_;^dLJujOAO@Mi^znA;k7sNX=0Gxf zog6xqWgOYnl=P)JDx`)qfu#mejz&?1FJ*(Iz-&+cleN=Xxr{t8dY)P0HT;pw11V_6 z8uu|HjFQqZX)N8<#DoNOBJ|y~nVcs~)@4l^(o(%s+VULp4hhdAxMlwJZJ)~AKy9{Z ziDAJ@u;9Qns7M7Op~tZX!q!$n^eUUHs+qPK)pQeb*(;MfWp%u;$)Gv#5`x>PgE<2I z5AFRH$4*f6>9l451VymQ&;_cW5$fph9PbJ`x{)q{PatV4(hCzPrsj~CC==fJEiY!| zFkzB%LTNgBO*^2R59EmK$PLrQ3(Y*3B)M~bz zoc9tL73~g7fZP*cUfUgLniOK)lS1|j zRSQ*t3RQvp0+>7ULunQ zd-Kx83e~pctBc&>yxe;b|5&F1y=zWGvH?bCBPIOOS1T`@Gg)P_xqH{49w0dz@9|$Q z526DyR(<7A#;T{ek~#vSd3zSZAyY-cAa7jH83`ffq5|bR@yD@`XLP87g)Jb!4agsM zY|chFyf`K1ii$8Cfl5Ze&IH$H{Wt;bWrHat|ED1#mVnoa z{9kpiV_a7-xMbFj?@(FfyJ5iZ-!EVWbN67rG! zec02zY%$B<8d}2J$h8*(NrT)PG#{fbiWc}B&u{MCd)}+IfSmskk=2VcJAS7wg(F!W zKKx!Qqk~1?*WVucljhP9IG<^ZYgWhi8|>7CC>JHc31NPo{$DrVX_33G$OcY|Vk51? zo#m5WXN*i$x=1`cxF@Y5D$?cqcCrSSZoB{Qz7)>D19r1}*YkK+EkNMUFcomfg@tNL ztl7aq8Z33yAy>sR*O6HY(wI<(swo1VHeQleX&|({&Nws7Ewa_jmv{5VZAetq|I++# zyfvLRW(q6`!;|~9v}74AA(o~foVM7YwNbGiXI+VahHAQO2j0eXx@ z(4RtxNxEe_Olork%$9VN_z={=y052IN$drX6=tIC?r0>PS<>MwO2FG@OB6rQhIc} zT?TEAU0pJLdGpPynbr?ENiK`mj2ACStENMk{-bGp?RaO!5Br|}O+3GNKkii4?t6B*icdThM}7dZ}rd1zW&l8*Oc zUko*!((72+(gjW}Q^VbvSoz7HW<)qqx_HmU3wn+KWna%3z0^mr1NJ}PJ7A1p?bKe7 zwPbn3Hn^zL#tRKq=gNoUu)8gt5e@A+91Ul4!fo0lD4o`?BkA?mNjwrsW_`|dzFQKq zqNR2!mO-riwVf)^TF^pO7>mh9Z`#<^fw$ga3|T+28IzFk7Oyi zRone;+>(FR!@q{5N3gqSSQn-Pgvjg>GY^%@h~?W3;(M2g1w*IJ2Xm(*TQedBYZWTU zQ4UB=oJ#$F9j&5HxR_cMzDgJd_56a@WFc#iwjEBB&9Kqp($Z8%wnA`XN#L&nx~Rhqp+l_oXuGnZ-x^cC0!(+ zj)l#-YvA3PU|=QS_2XH^R!!9;W9xWQ>J!#Os)MVRpI~vweIMd3T^y&*r@O`QjNq%h zu{2bd&<3bbokCkm6e5KOU!X1<1*n(*G@4lI9(AD5kIqH5DoPY!AmNFuK5f0Oie}!R zbYtB(^)%^ZSfr>9z;tuoxQ;eg(SD(D4WyfpNebV|&_+gcf#o^k=@bg_#$+?hEy~2| zMa81}nh7+fRL-7I>RB4DU!gj34IHG#BbEB7BHBUJDX7rouX>%ejs%)fD1(Y48<7t) zpX6WU!`+;4it)q{oHYdP<$5-)JIGPZ8}z(#Sf?%Fkwv~{!^DgQ+7jk5U78~*shbg2 z$hdT(qeEa<6pyPX-iKgw+@LOPn#2=jB<|7`?>&gj6I+<1Tk&2Az@#v7D8{(Zks0N< z=uvbK!VW?eMRbC#cy4Cuz(X1rTBbeNU3_Sm5R%W2xuw;AwX7nO=IsT#$MTy&&Hu2* zx-HS;B2X{kK>8eUY5c_#unV{*{!KvUSjoyu=VIJ{602^3>{P*gO7P_$!;1XibGbj^+PX3w|m zALprt9RLbcvx=FgIxCB%v1ZbAr*g07d19KD_?WD4ZhHe8TOOwXbKc>)@pzT=luc$Z z1FhLa>X1qz8J|o)_2hEAq4;UeGhjY5FaSgpTQvA0FjM_Vxpayo*Li^+KzXu%0 ziMNnqZGcHAXe%?O91`7)%AwJe%1SQah?F9DP$3|7c|f2$rQhg0%u@k{0bFRXhm=xt zd>hW?O(J)uz2U^Mm&`5bQwZ=K=RNAgTbmzbChrD?#;61;Mp^xOm`S87IZsvXdC}@IA}NYA zBp+?#^YBh8l*W&O=qeZ29|2V37!C|XB}fKG;q5`_lkZL zA?kp#0&R{OLc#?R)38H44%e5lC;(IOPx?C3Rw#9%z&Zdh^FSz55ie-l=Z%a zMZ$d6Ge?zI6Wzo6I>Dsp^pD9}Dmt7+`v5mf+olfh-%H($%Y6a@35ZQ`39bn13ju1p z18{%G2cQiQ2e1GHNCOQ(oRA@h8FCn|uy6aAak#;NTvjNq4(~GxZ-MW7K<`^>%XFCG?BR;Kt0v zE-PK+pQ+!gNE8H^^!KEZa*Gb@=V}MB4fCE}Y_s`u$drhLy`agrPkNvTpt4e;C{$W0 zaz1kMx4f6PJ*cR()%)?z^Pl=RPu{*%gLS8OZtQ}41M6|1o*L}@HVB8^gb zye>e>o8-zXLLKeC%3jhED?l6JSVG9Aq2reZTBp!sDR4w3c*zebn+Z2=R1WSn`s|b} z=ag#%ot_ip_ad`vUKn3pHpi)PC&{Hn{p2e8%qd#&IHN>^1@c=JCUp@_SC=?Z-dC~I zqlO|pV~tRQNiT5ITa7|jK8Sx1Q^1`U>4HOMc}PXDag$Tk$;d^9fuxt|HD^d9&t-8y z{9mt8B)> zmy{L93a+FR2dJy8onFsPiYWmD3^hE4Lu}?wB0%v~4$IFCgQdeTf(4{Yp9n(-WI{kL zrs~{4a7C3q8p7us$_>}(g3{K7K8i!ncLrBNk;!T6IO%mSJ|!XYaxb0<{A!`Xql>(7 zBACDl39wJOp;>%6Mwi5WGDrbYRzAqoV?;A1wYCfjW064VIrfRbF=Mrg1}_Yt7}7cm zuGum#T+FmS-U(g)ii|dwm8q;Ut2SrqMUhpU1u~W~3zKW<2=|N;(=tJ(XZ~9?B+W{X zBk2&+I1V`~PA*9(PQoR`(@+nAnblC$lAr)tD((&JSXAhTZFdP(6hJQmsGU@wPfH_P z)o5eQvb0PIx)Q(Z_ee>jjFiwurap-A)c{>qX2c2MQ&X)4_{;cQm&2HdwN5FP24uAl z9U%(i0%-_})^ilDh_3n$0=`Ed*@_X1Gi(&Liq&>97GyIl#=zVxVXF<&#HKjq&lpjn zl56i9`3|}Eg*~n{5KqLlKY3a%v@!hzTu8w3{}Lm<++!WJlaAW?WID=;FR?;=#o|39^3LxSm9but4am28 z=w8`Ji;IXmoQSw%Q4z5vzOcvg7BN5s(}GtjkRqs>nTg|9_QZ&D>w;2dgs%G-*78|| zXTi9zhj0rrylOvTnK!Q%6C5F5nF*ZSSQL@l=OdDWtTP7`f1~XH|8ONaDtlKt+%@&N zYHHOpuVkWV1q*XsB+S}`zL>n{;LOZ1>_?nUf-}a(@=$O{Y!ctgSIXjypFOWiGk+lp z0D5M-O!bz;v9;LYaeZM%dl@D)Xp1v1qw1Ozd% zVRqXa;#OxXRIRsAy^AlARv?{;??4fp&^dV#w&|pE3)Fx4k^4pO%yYr9k3kYJ$nK3yFL-7$4p@2Ac(aN5Aeu-eM z#%VNyxv#GI`S^AwA>v&OVLC8Sqhxj)``%Elk>~5(6TE>A5o-y6&e!C8<~Q84x(>^Y zj^V>Zth%Gim>M;=K!%^(RP_ivWLm;_JHJEA>r)(Gtb;hG>2BQm7g4=KgDM=QnCoza zN?8DJ(+{!$2354@H2+t+QOyHo>G3{-Yra^-DA)pa(CA6_`a}nI zoK~`zje>dXCFDm5G+ICRGg{H0g^cDz#~jnhNsd5hZ>XX0wdFPvk~jLvPe7OCO@4Bp zpC5aNpZ~pklOK4epS;=6zw$OqPB`k~fp?NKf0XpM`1!*>V+qLtKR^0TZifwCKErpT zDaE(Kl&n%8f50Aj?UaIj7!Adscl+NZh!0Z+h{q^Hf*|gHyFJd8;T@uNOz%E!gSddj z12Go9wFsGo>gB<@{JytoAeWWBtuF&OTZU6U(*}n^QCVt8qez&{K~UA%f((m%G;KZ( zi$EwcI2__b{=Bhp?CpLs*$MLfbif1e081~Qc?Y!74e#=A+K!(4d8@&dAK+$M0}JsY zRv@2ZRMrR^04l^_;3OYzXp6oDXCW9K>Sb$sBNj;z+wdWuW%aRx3p@TAFaPBI^q>Mw zcK4{=L3lo$SEhZ%?j9!1F#hz2$fv$h^~q293!8iJ9e%Q&<~~Y09&^o|Et|``e6K!L zl7FFW?$IY~E`?lkx%qCJdp{iSnyb45ON9zNmCuaoPHFes-2v{bx&LghVKmia5P=$?>w<1`OTNq4rf+xx;0c#48 z=`HInOYU_SR@UXgDp$!xx|sY$QQ-_+Fh`dHDTe=b_|g}xRorC(^<>&QkguH(Xp zy21IaN9J6J{9$*$!sH8|h-UyNuaZ>b9yyh~$_(#h0tqC8^BM>Ct-gA;za!)~YiSzq zF&I!rj!|9zJX?vE2NNiW#h?P|vr@u4%Tw;i+#sZOGBAlRGD}_ax zCiik+hwKI|bsgg~@~mk<9>H9S-BB+FgwT67=#k}8Z|o{>nL}rc4B>=c6R6B87YA+%Jjb;nIj4EWz@liiB-k>Fq?;@0lNdC7x_ds1uL!F_ZjoLO>Qc(T_UOF z0EV7TpJ{t1bSbeCro{?fUazA?X2M_t)37e)gMg(7-%(LxY<$3=KN&+zbtT_0tRu6CMA5 z9~#eKOlef{pHu^51Z{Mx+9>pQ{6^oe%sEeHooVMj@)-aZxgg#uvw`HKq2P-T29FL^ zn1YtGWiNAIdPmbN^)CAw+_3%-6E3X32$1y>u7R&;4~tg~zcks$ey@Hf>{U1rTY%9M%AQ0ki4>(NY4V|p^A>+1a4jyD5l|(S zN_yfhS}1avpcP8Fmjvz%oQ(Kcbkf5p^CuZL{vd0`JhfU*H+)k79R zf=R50Mw#{Rr_~eo(CGhLJ>-@Xr1aqx;hkI{DnTG!h^0(Dl(CH9E|M9WhZvfOZvSQD zVq?~A;11jp|AJp^d4kDVDsX2OX^)j|?@FT|H9bp+LUw|Sp~+~y#RUUge50=ThAXHg zYg&b;!jseY?u5g6Crk)N{is{e79G-o4YydbWP|E*wZXDe4AF;JL~)l?IerI29n{SV zw0UI$LGfpWu&wi9UI_y;*q!>H%!*lZ9V5Zw8#~zIXJBT?V$S(fAMwfB%<(xQWyCWj{(_pb)<=b7=kOba5}5oYTm3#hZ+z4;qYl4eZNJ`7YZt0@lBs zibTDy_IJ;Sc&eQVfd2Zlpagtlhm0*LDXM>898{(oTHA8WbEjYgAP8Titbk%4*W@$z zrQzfd53F77tr+6C?LnnKi}XRU)4e5SXIQMmlIdVBYYeDP!Xe&6``I}bX)O{<893dg z7APhi^b#_55O?zvCw;mLVN}!8<0skn>az{oU*ChtG6*Z1&u0Ll#N?F|4|_h?nvNzVa@`T(RMll0O-`W$pG-@SX+OSYt;u0{GW%6FQR z9{CZ)&A!~=VadW}UUd!(pjjoS9BHr++#;X~Y^-Kg2GkOf;;~hB!7D)09aQ3{Y65#V z)@Rl6*RjgGy8ZCZL%391#L<&q@|>{g-RogcgdUq)Nc7FXLzwoe;p5 zAp3t{eO3o>y#QSA0bZ8{;uru=WIeX&=dHl8hwYO}n15#Pl2tRf2Pqbpx6y8nL~WN( ztlWma(cY}Jd#APrZ#c|K>S23Z+hdfk? z!yEcBGC+v|l5o_L8(#P%bJ#TnRnMRRuqkHuPGsD`ZoY^Rq{4txCpTzxgE@m|C%ACK z_PJh_oZPsZ@}cFHHWNZrBT(>jx*wRd%=BJ%gaFYGe`wSd?+))=&ET z7)Dp`-wS$hQEj{vGqTft){GE@;9d}D?Szdo)z&Pt&S!iib2*eMEXE@v>zz1B2~5SXayTI>hg0YQvs>?LELPN% z4O>ZccX7B{KUcaHirl4oO!jI8DL1S1Gp6;aTy3!=3+*KP9nWzt(w?;HDK8NQ>XaW{?XHHo=<%+a<5(TBS@*2_nN3D z*MzWu@e;5@Of6Ds!-7(>43N!@lC=P}Vcydz(wOeV zob;HjWE{io8d;_>7$uBv>a(G1LmR@l0ehvZ+{P`c>*8>o4PGoN_G0(p0DY)UZYXNm zjx(X*yQrNFAG>HKl4w^J6)G|m0_Gl-qa%DdeQq*D#;X3GPZg$cvKr{Iq7Tg{JXSfx zQa6Cnx23#;8mNZSVwkD#SuYl`Ma`2}I{~;?0;kx61|jwtx4*lPdrVPFE{d9JiiuE1O>9u)oqpUZ?LzR?g@AvE&$l4; zqwCQ+lg|~V;r_iDQVfQcBH^*eNolY*t(hof9k<~T$q5xhg*3HSs#xXCb`eE9G2HvC z&WgSPhDiICkJ%eaq+#}IIS1DJr&yZrMhd?Ot{yq>+F7Q5{iG*rCYpTCK6)gYjP{r8 zF!LO<=zC>Y4X;)D6_>Lzm(xfpHjHFtnQ_mUL^f0oz1s8%8uietNs)L@Hn4Fuf0iwW zmwLeX(K2`^`DO3lXUpRYdmoP{trm@?W|xa!maj{kE2d1-zvu_VFLvj?5z#}?K=uB1 zmnDVi%X@J2^kVH<3{;|bu$@t=T4H1+`k$->W%eo-y;noQHgrg?O?p4d6X9d94mL=J zy;MJx@Rf3}9`4n^W8S&Q^>U@XtjOif&n0$>;@>VBM|?Jz(1L-5jVn9IHLm|js4A56 zWN6{ReU<)Z1+H1DSxpMmq@ZXLcSU>jT5So`7QI$m%GVNkEV!{G*O?_sm;%mynVAW; zq;n#CtMxx!98XZnR(uOy1WzAM{a3SABHfyQ!|QUQ<6#+_`X}a*yXHH0t-?AH0mzAM zxj|83&O}2QDN`_`m7BgdIqUp^y>C3=XwJ--Q5T87fjH@v zya~S~469yWug#p;Z-jxjVeKQDq{a!bofBPiC zJ*)pp2X3{NI!LMN7~zml);zcP-YKQa%;*Rus*C6>4{*1B4tv)M~xot`O{{ym5`mV?e}Xp%=2uD3>!YNB(-*N_<+BQ zjewSh_EpM$Y!mawXMFi#xQ&5(FT>N6A)&inE=gu1MQ$ldY@A=W~|BY=wRR~Fgv+Q`1D$ezy2UgjOMyqr&fB?ftd-L75rqL8OT@?2ckF+ORJhHO*r zwj66b;c_@;Nij^}1Key4L(FXacNN)}$!fP8X%p{L3wG}fU2;Ubqkn`SD zQO>!xpa7maS=ze+i!;s}%v1#gun-B12`Yi0mmJ=?i;k1t2VY`q4lwZX<{kEf4pIF0 zwt4lfbP%bcFo$4*tzZ%j;Wz_47>u$ zLMcfHcbOud?Ce({1T{(_+#9(w$dD4})1wcsIF#vVz6(g{3-%GAD+>-9>1{00i^!}# z+&cS(8x_H(Y6oA`F$BR>qoM#I01I0^e+;TU?Q~?9cK=jM!)P&Gf&f=E4C{kU|1yL) zNe1OwlMO@L6~cNs<^`dRx-UsT_wyP zTLAONP7Aa2#SBtk=xE3pgR?qmSt~~id$do1aH# z^;eWvIbP*SfRgXrWgbaq|I*#PI z6eqH*9=M(Q-j>t>9sH;U|Lm8Z?|C!R_a`4ldt;fp@D8&HprHl^G*B**9g833zdF~{ za`Id!`+WyZ)j9q;p2k%%5P2*P)e~e~%_}BptS4a6ULT7{wpg&gk97#tV>$%Ne38`W zFe1iI8YT~0gT`Eg5*oxjf?!!7&48CQE5b2BujsE@(N(T!N>N2ED7ui^4*detC*;O_ z6jtWU+TarNc$el@f92? zBo4!AvE^%hgH%Da{9;Y^3#G-_3lgvbJ~Y0kLR8m6qKIE&uy?2O+agIOe3J(`G{C<7 zfaTyk+=i0`s}-O4)pk&yuE`-eq9cij%@kDSoLDe%W4u=Mf33g&-HaZjLQKLrU{llS z+r~Fh=8EeKCBlCF#WCgqTxI}19i!8A`!jWF?6^>>#(Pc7N+HRW4!KZ9s!wNcAU&sd zc81RyWo8*xYxRSG$E9_B^6Jh&(Ta3y#|?`bN4av^n02LEm7|ZX3oF-;(?`}&$Z4nK zV)u21r77e5Lu{~U@%D#Uo}$=YGFh`@mzfUH*N<(cA(>pMG>#|ZNTK8-(o2}hBN#kh ziP4Fx<*@2ABWV>U9lM9iDog+_95Ti9hP}t|;luNa_VF{OKmpe})3{tX=2j@R;XTD= z0Vcz~zm}PkMJ?F$1)%jR`HBM2x(=VqVH%jE37wgnFx%1LdoTKm$ovjGwe$KrF4%2? zrlF{`ILe~aeEz~*Gy|kbe@Pei@`zgkPNUKzhch!8c-*B&o zS>&JA%5EUZX^b3C9N?DH2MyGN%=VbgbMoXP7%7fBaQKvi5Bc)@z#=&=4rg=}GjI3X z^fc3-`MY;_A0iM4^`?oqKt?JJyJCPj_B;8=w0J;i&J7o<$jK%10hgJVLJq;n)|jj^ z?ilew*1(RdXrf_hZ23Uw`0+ppCQK1-r^NJiTlof$J6MfKFlarrYci!54-q?q#<|Y> z!}DPg#!ESdiCCKEC^6rt+fj!Wg|bv>Vb~dQVclwejLlh4!=FmtSFt{@gIEiC9uJIK z#|XP$9DdDyj|OgJJr-oc$uAlizZrB!mEm|0)9clImQp%t(BE=RK_f5u1rS^dmg%}J zoZ8h*eo1sWLdFrgnX zcFQPOs3(qguW8ZM0p=idta!tTQJPfzsWoe|7}4Iy8|>c#h_w~nrk#3CiKbDGVg?_H z&iXa(^!HIo@llTb{PrLoj=1rV(8U1fyX^S^jt#W4z%srvVIR2AiMbpH+64y=aAXaa zrIn50%M+)30nZKlzTqg4ot=F`Px$~tNC-gn?%?W)`hoj0y z(j{~jABr$y0h=={)ib6h7Ae6FL&gMlY2HrD*zrYNoLV9V!cy179dmelD^I zzSvYY2iL?w zA5(7-V##;kwm{X?Y}6G%Wf@Rtqke8VMbX$dL3p!XuU~QMYncbumUU%q(lIaX7dqlB zq(f1i^cJ9y)cm5i<_nUVsZ-v}*n2{k3*NKn(A9UB>T5$_J~=O5?q^>XyAmM|;RhXI z>^p94=MA|&a4LHTxVB(nebZv(kR8p*ImtRfW*}{9=AxMoxl2PHPA!-CD;gk4XZ`DX z;-G8Ktl|5p{T{L3hy9{E4(f|IH0eQ;e9a!Zi20Hx-1dPyUXTb&6B5}kvYz|>rd8-Y zc7K866ux@lo;&_H>IxpW`oC$v$L#lOe)21JbF{$au_Aun%y%)mITg`&T;~`U5*566 zYz|2sYaX~Z&kEm*!()aN+LZgF_WM|Yp!8u=*ga^$1Bcx~S8CRBK5D<{Man+xN?}n* z|B~>a7F5%HMV}%VS*~P~iH>EYYjV8Jz~S`SJ8YEkY}Pg7T8FN37&0a}@rKkL+9#1^ zAp~~@G_=#Hz$NXn#%-Mz83YyOZb#C(nsxjXXI~R`8lYls8nBLvO0ezZdaP!pW4x&Ud6IEhd$aWU5XkVaOQVCb24m^px zZVJH$r#jD3p{`tN6Le|j7umWkeZ~kQKtlTSfBUWIMRu+qNWs@?Pa1R@rl%TKGM{cn7z(nt?$?g1R&KieW8ijnYq{y1p-4K)ZY2=TyF`M#6czTnj z6-e89QTNR_2tm5`@@8Cfbv;m^K3v)KTe5O(qqs7JuxEK(ig&Q z4!WItT;dA92irNFRu;g0L{C^82W_B#Aq@Ze9iRBgS+lzkmlcMhY3{081Ws;<9#cAE zlx8D0?Dsgk?l282G9tP8TEz{vV->n~4qIr-_faTa$fj9trE@89)BrqIDdgIt08oqc zYPN!QZEM~;W2wdzAvHzAWXWTXrQteOiXvi;dpEFa0ToL;U#t)?Tv+8}MvptczqNyt z$*0qno!>twTEV`A9*Z_M)JCGoewv8-%+Bm!NQoEwhNFKCeb8VyvX!Ja9J%Lw-!$36 z$Abm5U<($^x$$T_8<~@Hfei7Y8S)%Z}RNyFm6vTVLzE%R8CA9#?K`Q`ztZdGskpngxIbfAf@O5c;s6et1B@|y? zc;v@Qm@{)Q4;ah`N|^f#m@@@T`mYZ_52=H50FD@dhf4qt761+cKyv=;c7!#<$kAlZ zhQX6oUow=8M305Ml9OhFWpl%eC8l>?82&!*QB8xxw_K*Dy zpE;1;jUIA#k$spFxf&i$t9;aG=j8gGyeKO1`=O-CP;EQfQ4R$q*keK`nS zR^vZwGTmiss#$+B10ns6)l*am|SugaTCIY_?Ox+flfJs>t17zUs7ueEXDA66ur zVImH0Faj_Sg2VQ?K5X}$L|o2#ER=P~>T68CgE~~t@*lHDR;37V##;S*Um?$>36+X4 zn_>q>z=|ac8$JZ0c#Th6r@M;e%#kq*SXd1eWHnYcb8bQY*)MVU4>M86mdo z%!+GTXOhrZzHD<|*}=->{HIb)=VtZ8S(8-{S|r?Kp}DqK()#wTv>knQ^*L#KBgW;S zDk$KIy4GsZU>{4}&zi7I$g%Z8Ys}{%ZQ^h)#Z__kB%B*S@thtc07{UEHQ4JlZ61n^ z7aLuHI#TW&H{l_|g0!;QuTOzNcruh>OGbEet_rbWBdtD^vA-hRWh*kpr^R5EBDQlp z!uaE%Z6sy-Fm?MfVc33iV($F)M<)8tU!Q%XJb!)p{zKRd-g;Mz#ZeW>?)nC|61rY2 zM`T3?Tfgv(g;-#F9rcuIiKVjNtCh>p9tR3DRr%1=0JXPd(E8&7Wbxzx`;*i!R`U6D z0QiWP&=BaidYO|((mZeJ=sX0KYpE$(s=m~NIZMECi%hCR;0+V)Fxq@9mF)z+Dn-xsN`@*)?h^? z6|Q&8F`n{8<`k=?n|+C*ic&cr^WRDYrUif#DzF5R~V zeBBZn6a7AXrzWQnAC#E?9!XOSPhgz2>he{EzCT*5(vc*IfX~ILYpEeQ*y=r{)~6my zZJT(qlPNyh?M}rg+QCQCrLr7yPqP&?`nWoS)~R`5MC8GgeiA6EvGy&r9#TRQyo41) zk^mD##a3a`#LZHRWwmyR(2UN9hRm{w7k-MJVF9ANNFHI80h#Sv>~@lct$Q*FBkMQj zNDHdreA zB%`)}&08ZEjTr)BF5FZ#{Q5KeeVGA-Tn0$XN-pGZ9+)vsGo*y*2^;~}!Z3fPKITox zr!!!*Pq*Uq5dezwFKRgqX)z9-{Qo%rvOdBI3GIJkaAyA02%9F!tlc}#nPX}sY0o?t zndF<$7?VP!Z_+nzY+Q(`T{-HMM1rXqt!nJ4ObxT9{zKUiW+|A8*NF0|&Md?)&Wts_S=`v`D`+a&-e$kM!xUI6?+OTJ&NNhgF9B= zV}-NAjSrfo{&wO<9Q90(q5;wY4)FQ}BUFblc!qS*uw5^1^TEPv+O~U8t3z09#&=rN zfq{^Z4P!gR`PUI{UoKX1aT@J(es^HU(IOqM@=`MV6MdvDCp_lv@(h!L{?jz(Dw>uO z2g9}h1AeJ5C?6TaK{K6{-!9|@i8P`^vpcIOlC!_;akz6cBSzAS62ty>T z>v)K|Sv+VCWx#V&3z^-v!^hILGKOw0vJKzELPYF%*>Uh9`<6D&kk+_h?H7CbXo{)A z$?4?Re7a%Lo@#=Nt=EYOl_DfCnuqxIsv@Qu5mK#7Fqua@ zDF{MIf*_)pL|A?S-AEs6Oln$$Z+foH+S0!@DAVGq=&?Q%1?6zTm@U16Sr`Vl4;eyD zkUgmp2uUvWI$F>}|6S$j`;9A!^D)sxuUGO1gKqLE@yl*?1H*Am8}|S#@EjF}OtD1V z0ygy!ZD6i$TZ({LtEHsmVr%7g;;^hT1?#XhErgx6jkA&{>AwHB2}}w4@wX=2ybsx^;Ul2Rd^g?K3%XOP?yMQy9sCoqiGneYTn>d~&=9;yyc{GOU#;Rp2x z9nQL1h(yu8>X4W^`<1$CG%<`l{^pv4Na#sRF@mI}Y>rZR(beiHhpy&5n!*iUJ-x^@ z^>6rM4D8H?*SGn8YdZXroPjmo7I(EY$Q*a2O^hN{#?b?29_bT*eLZak7|sT)NX6Dg zHsgY*kwF6%g&ga%Itb%SZ+5jTt=}HvggZuxh$}d{@IUf#5al*FuH1%LgOd}}rjAd9 zRhX#60v?QiptltdD^O=`V;#U-Df{?#nth-9e8y8po);%Wd-3x$jO7qmXw0NbESQoNf0<&=ygcl;@YOQf%< z;v}TOwd^FfL~E*W0$j1MD#4s2qkDXSn)EbjF)bos`bg z*^puW$6QnQxPgn$^zN_w9hG3do{}KQkEQ>HAO9xHgw3!tZRq9i`}42=Syg8%t=e>*WaJrY57m&#T?BBuoM!N(O{)PI!_0#k}k z-jUTb1MF|t<`TXX$Sjb?wyTAxgq>PyPg$r?h9ymDfsg8G*ddEN(78}9S?*4ph7*~G zGGJOU;DCXyY(TbH(}0Yq0Ffvq0W6?@=ppd~i3XDyCJ9|Il;*0DwMM655|~{D?k$;3 z71If6-F;rDz8zQW+qEq?CS%*T@>}1L&paO5^Ny_~5I&0!gq-RcFxW5kJUq{%S@MHA z*WEp9faa~u`LV1!KRJK!!UYM3FJw5I^rkGh1J3*nP<|%DHy@O1Cp8!3gHo1S1g~Sw za|+UX<)76{o@Yp4(~E+mJG4iT|CZD&iVy{Bhct#1PL@jug!wOXrJ$~;Td;cO2WOb|^{UCki z8Mb?lguOt_AcrWeFiFGR_xO6kN zX3EGZq!rG6E=^}IxvB(RCr>UzG)YwG_)qApTkNzc13^SGvsO^KvVegd92(#3np_;2 z1&c^N+l3_rxRMhHIPgJwJ<5QUIc~$$m|E;WGe{6Ssw+%Xw8(0x;k{c{3|62tl zq;Z(r(K?VyOCX5egbAN*mCc0)B(u3js$A`^APD5pfr3m+0R#k9gtCwnAi`P~e|dI} znk+~f=u98c83p`**n9s#JFl|N_x-W=KKq<^pX5y&NNl3)y{F8CG1bn91;jg?w<9T~ z!|3&&>nJkbJKhT>Gb5>`_Iep|gxoPgg$PBXQz1Z+v=)p`(TH^#X@H^;0~84uAwar~Z5HGZA z)-P9q0b6R(vVvK(mwho9*!Bj)56erC>-!}h7R19%XtrRPAZ8mjFBCNe1?0X?h|Lra zfq;-*KAuUI@<`1|DgdVV{s1nfw3Gk2Y(on63*ST|QM5;`jwx{`^m3v;S>Am6w(+#= z#xN=!cJqutnn}Tr2Z=$;noekSrq>#CurBZmW^MOc>n(Gl-X{8(as`a;;y+<<9Zxfx zg@tyb3&UwZZl*T#4<-I5z0)KcJZKhE2Sb{saaG(YJI!_9=vv!qH&8WF6QVGKo|HTIh2RhPpd`nA$Wh(8i!<91dLY6D5 zt}wbEXD0u2wZuACL|meKBdZqkCTELY#5y(eX3C;egFM83o$KnS%S_S5VNn)KoyRf# zTknU}>!kHsx6&~Iwj8Ys!IxOAqG7SxzZMA#u}9g)q`}Xx?;ZB84|nd)M!+RSSY}i( zgN~-o7BW@$=$_s7TV|%4%$*1@FR*k%jns&_oLDz(P-a)v9Lp5kl_{9287ws-B32gR z9vJTe7CkU!2tiv(>; z!HXn(^9)WuV4`!;QH|U{`eMXX;_Ya-f~JMkt46Gg%&ku*AL+gus&65Y=EQW{X^`mr za1i=v0cqa4!j~!Gi%zs&_9Dj@#>rp68G;625LaA4ZK&x$M!+2&Q}h`!y&LjCCMGi_ zDqCg>?_m_6h#?aMR-*|d-Un661u~kGQHR*XEy~FYkJzK4)h4XKJgxeuxrW3aQx;KW zh1W`A=oF=PSP<*W)96F5N&ULWy^2x=cgNPNiAEnCFm>ij4K?l?XoSP_H8q}oCaot$ z!qO8pWGAc60Fq{$1^Sty#3QD&m%Jc;yG|?BWOWH30-RKo& z7mOw-JuEhRfqjA~%xJAbMrhzb{p%R8g-qtgk7mcc>4Fz09~9cSL`ACT}?&V0m; z1R@NgNv|~^%?mB;?Mo8uaWhe+q?#P-I;jbpB3VX^K@#b!d@=hb(Mr7NSpqzXwH&3t@o^KJQF|5$l3Ia5txYqb6d4nYaUYB`znp>lC^%V=U2YH9FoP~NsCw}U4^aD%97a@s4_yyu=acppAwY$*eFxX6w!XCen=O7 zNXQDosfbAnuv`Mq{)NW$;>j_^?J-@|9FlGh_WUmGGWa4l) zqD20YW%Exl9kR#B8e)VPI*&n^#bUE$$702C!8?8Rbb$hb&$Gx96XP2|nINezDX@|l z>E<<3J)&$==uFHMY7*1@V}Q?u`RpA*rDKM>Hp9}Yil4Tn0nBE^kie$zQ$;2i=vR^H zVp&a5@j^D~!dl=f+qS7&U~EQn>g9)s#LPrcz*zJAO}Hx?r+{@xj8g}x9h`;Mxj5V$ zg?xq)nZ7StOBU`MTdOP{^l5FDzpoQzb4(1xGva1?>e@z^BE(GKBOZczB$7lhzf0SQ z8*dz@m=%6T;B+8S{j$&&eFU(^4;Mh2l}@*{;8z0ePgc8T$#mP zg2UEeF>8Ng0vaDS>4^j=DRt<|>w1wibV}&YJpb1uQ4Ga4WU=i4 zzyY#|ihBxF6;l*3N3oN_ZbPTb)}|Q^d-;!YVtJQUI1X>%?=%Hcj8R?ijYX~q*HFFgja(cB00uIG`IF6hLbwEC=>rT&l3cVd7gfNO ze+E%?AS5Q)6+=@7MWY7gHuQYM%ApXBzP0zbd&2 zP$xTz!GB_3wqJY*Amw~xUg159JwFw*Q>&DALvT3$w5h<;vM_K~IUWv}q7h$a@(!$s zXB~lyJqzhE)G11$0NfO%s7UOfgQhRapQ{turV-#P z3)u%o11_~5&2mCTD|;;zfuqI~Z4K9Qyf4=wwis}}7u+O8}u*3Lc65cTt+-+vI3Xy5d_wEgm9&Av6aH!-)3u<$h} z#h*kw#}PF|#bJ3P6n$-!S!kXjN7d72!A!P0p2S`=K})z|5>$`3`R0vnZ9nX8QJlhKr?xv~}vBb*!W{{*@DbqY)3Etny_N3L#d^2R5 z(PgD;MP?YWWGh5K4E^6Z(lBKP84Rbn#Y~d#6+9#TZNq`@tT00w7A1z669=2>UWKwS zKtpOhv3X{;R5=2o+2qD-PWgPJ1k$t~(`8M&prKU{0-3};4W+qEXDHWh&wmMzW@O`H z1NVT0j>lZcO8h3I4pBfZGqd0ljGpG0;K$4QuEEh_Vv@UR{=gjvs^7U~Qjsm9{(RHKHVp?SqRbr-1DyA**qR+t+^ee})X zg~HGUZFVaJ5=ax<7J&eESY#mh%ai;=(6OY94dvBrBWj=e#+gSIenEZZ|Y~s>2gl5?nwEJT--=d2( zIWu#`Fy2vgH4V%_elN%`tDJe9flHBD9BIvZFigasRUP{ckyfkju%kch0_e!J zfM^~Lf@PrjK zC0};sKqPwYMf2sy7R^7dMe~*T>G2~Zsr^-49`)HO zccFv#mN%-EMz1-uyjZ=mKj1a(MzvU%c?P3eOXWlxlsR~bw?V%_f(WI_x%k-3s8;5( zUR0x-FsgM6oaS+3U=?(& zjcqjH#v z!%RPX%J%P;A%+kPOT~Bb6pUkUBj6)G31&CZ6D(#Jx)>rxtA1%Fo8dQjiYIwxCX-_@ ziks0P`S31RArsN))}ob1t;%J1vLVcv4T^Tm9H$dn9IzS$b6h5K+!HXzF$uvERv!}N z+4k*g02gDG?M!x+u?5;GZEqisI2=sBFx~9DMh>7%SP3IL;iMkuj8Q@qUAHuvRc5Sh zISNazXYI0?alOFoL*(0_zC1V#1ehI5v$Mfhp89eRl1NWAe5p&;Z>bOdSSPOxGTq{F z8u`pnW&O286mv2jlt!|>rrQU{4V)HiwwiXnPNjih-qUFc?R?~af%jC>Qb4d`Hq3n2 zuzlwGcxmmEp-ZMtGBvGz|2pEo5ugowC*3yb-<>>0`X3|xB7y0e zwoO6b*=S^6N21Q-T_!pzU~Y{bG?_@-uR-vH`GnJ(xL_FMOPNTuv^O3}nKzbhK48H;m0!t2AIWwuvO|bU4|XzYCrv zKRukD<)_!MWXTNxcE-@OUlg-nBu3&J93>+$Us=!OjKp7GO-1~}wu@5Xj&}I;$(c_s zE!h_u3PhysA)Q1)H!wB|#PD{p^+2bLO_`*p(22-r59cp8_oG5v z%?Kamnxkj7x!Thejp`}rbG=pOvt44B(_U)tm z6$uBug@Lv!r+wxcf?6D51JzxO)QD}?C$=Pd_KEMREsQw(o+z0s=3gg~&!Pz_oj;)1 zCB?bli1YVIc(Z4Jjh&V!z#!XRDID+|dPE-i)|uD5RsnL?E0d8R@&=F(S*owYR<3Sn zt2G?MKuGg+ar$LsCi|{!=H^-nSxI&UO${Rp;2WiLWU-5UR5fldVOJNC(Kd;*>|d~2 z7|19wVh*^jkpm@9e4R$-`_9e3Aif1zvJ%r_vJ^S-`@*bet+9pl#_mcz?794 zjnP;K0G6*@TCaKL^Wt(;ZxI_?a0~qdH?Ph=@TVSy{(-@9&0GW*I0tHc1Ok!6Q2dx{ zAmnNaN>qDbW^w>*Iq$tD$-dI@qs%9payAj%P0l_J>2l}2AaLimBve}4BagyMb!)Ssy6YAZ~+Hrm3nE9dxSU9K)7 zBHsEKB0h$Q%OT>jK1>%85nuNhB0h$Q%OT>jowaWs=R=;0w(VbLQh6&8(R2^F@?GiO?d*<8$xhPy~652I1_B5pLN zOru2^sx;cWmN7p+TDFYtA|Q@ww5NhbOBjMBG+NpIw7=B!wYf_W-;$g#mU&#du4be< z$wo?t+%!G;8(qf*OcOfp2kU*MqvgI5ksHh`aACeS%voCb+SDD=Zhkn{R!`QVn(nFQ zHWC#CP4`ULMp~7x&GQ%WwYjqCYtvGHWsIU6wr()L%im+M^W4GL z=Jyx)+609dW&0n8ugyHjISA^tIoq5w^_qx7FIv>$h5*jRcl_+PwA0P~27%?hZdxkS zZI97q?SzzOQFfz(vzeX{tHRCMR1i}0y6haQ-D?7(YR{%}_h8S4GFP$Jz^3yG-91WS zW76Hj1P)QHM~}OQR0YOW;yXS2CUN(0FtP(A_t5c__7ZH**7r;59U%5{@jO|9Pl)aQ zLrXaB$fBVf%#CU>0I7@CmU!owiR%xt}993WhM@M!}OwHwsREM-~M8=c)~t z5K~Rz8|2{wB8yAfUW)vSa6y0m7>5#E(1oe7-tvEmr8L`=Y+GIiRug$WQc>cL!EyHb z#Jy3jY*6|wZ1hkS&06dwwc{a|ytR$%x(rU59_IAW(~a$(b_qyCm#=0-!CxmhN+aYusHxy9&ZzBP*S zpHW^i7*x5g$9`?Wf5qx!Z%(HtyWB7jiAl1jRo*%=zr|Tv5=_`Wu;T&%SJcWu8xc#a z3@Ni*$;k@qxCLxT5RPJ^(qBlbfZIm!ii7t?-yKCyk2gaU?z}hJA~lHF0AAb$QQQWm zFndg9{x;ibRSeRI2$3*Au(1fB5ur!4)tT63n#vd#!|NHJ&N1K_ zW)O_B2Rd;-Yy(d*+lq$9bsBsVKBhOe3D@)}Sj-#~yVM~P`Zfc!ML={wVM{nKLm)j- z>m8sHO1cvh#Rl}gkNfKVbffp&8sZnJg<8ym#{f&EdTXhP)YM z0|JdPQrMkY^plv$xP=WZgdZ0{2^7{aW$fD{Vzr=ZU?M*5v|_=?%p()j5;-7rn$87- z8E7y>vzaVeAN#?b^;!agspEF53^g@}JzLhP*lGgMn&GVK>}d)0IG4kh;)`V#e}NI= z;An#b)7|lJ%7i$N3!Vk%hoeb01@a*nWM7UwxI3Q4M&Yi0;#1O^p#A1Tf;I)xLXx^7 zN+M_$QBtnK44!adPS6mZd2U=p1dWjHnjZ+7E~DX2RiU`8s?9=3MV(djARD5H850KX zuYjOY*y3DUL_dcg0L#Fh+lxre_!E#1Nw2sxw*au(lV zOF;GmaZ#3m$gX9)a*-TYDhI2WSBm@iLwxV060wM5gk~i2V?UW=@q7oDMrzsVqU@>z zCR98PzkF7qh(uJ}O0%lVn$O=+x1CSEL}1{(wY-JFjX5iB(JS=8uwxT^eC!4|-Xf7+mIusjf4pl5dXS5K{rBgoxP(B#|! z`S}rA*P6bS!1My8iNo~psk}#xDd~skD0GHKj^L*h6>~fIc&Pf6y zN)!D*NJOPOYe_(;VoUM^`e33>B64Oik_Eu*-?(2xZ>zq^n~s`MJ-6o4mR6Oo4l&HwPJ5e;<-4?hvD&BT~^z=xOb}52V2u#w1Rwj8dEMzPX0$g-B z98$bHDn0{TH|gXjx5<3k(j0I6xqOhdwNY^DgEpPl_bvD zl_A!CiDtxc6rq>+S$W(8RF0hV^FN78clKx{f>}7vo@A$c@l24J6hc)plQ@UTOta%s z43NwOE;Ym*n7D2gsD(9grHwZf8@aQ!mN|=m9`s3Tz9(c5PSqThj8H7;{xi-|8F4)h!ZRC7 z4dW2^x5~)_z?`M>&IZo|TXKP=8bg;xWVbsQL+{f(bh5!xkHS(1jK^3iU3>xWwcKsh zbcO>KjMUMnc*t1l8T-TyxMHd=K*F~IFx43`Rb4!xnBAr7S~69G3bz_=NnThnRqLH7 zPlKsez0=AY0l?*v?7eN6L;~oP^JF9dJfgP6aI6Xf@eQ;s-m|=I5qRZX zLL{n{Tl9wW+7|z}N-l{7FfE~qwE_EJTbz7sY(W__odJ>zGifAz?Ki|oh`_R(nUKYk z-cWoFBsml9^pNraT^B0YZZQ;kwJe5zyjqJPHMA^-@APw&A=>@tCoNjf4;C#vNgj?x z%e_)ci77xWrNtz~mwuu)6UFg~uJ zyW-~;*{)TNM_1{<%Pz>SWg~CcwY*O3TE-Y9JS}b4vhh`dP0O_Psn|{Rgy=yTNal1M z6RaE?7xi(Rmy4H*808r%j%i4@ei$bLgRflIL3+0+*JeM%g!!UzyaRsAxu|DzBV;HC zWl)6gZhk}vOpNm&77NZ|xWrqDwIV{5=+AzBnIcv>CRnbSEIXlK#A>He!U8%Ie1<;j zq8^wbELoQYxa>BZF70=JmSj(;h*=6T)0mR{lZ{~cyOUMg_24mX*TXiqz^)fIDxg8j zSoVwqwP@3zUtB$DHmZ3st$h0t z0~(-M@dnPS$uYoOh8&+CAr=|A8G65!5aR2>>L*{D%Ib%Y4dOjFk}YcWWA7g&Cb2aE z38;*2fP2E~N6ujNqcW;Q516p}P3Bm{>UWq*SkM<__2XEqWJQgosj56p>P*pkiC|e< z{f;IpwEB?|fooM(KMs;ImSn=}#{*GJ(Fn-(K!fvdFoz4zf-{h%lh&+O;! zGeJZ7T5YqMhH&?CNk!P7a-^bF*{radw6^Gstu|~{&Q_txVyh<2tionhZ_~A_?T0vN zD331Dn9a(!>6Xp8gw3jNHmiQHS@l|b)eZ~rY}w(4U;0|vF(swsH6%+>0GRR$xUuv{&jr)9bFsl;+6n7iewRk9vn z%W`F#sO4^=%}&E|<#l4YQk{KCUHzuzDw#{>7-MNCEbUf^Prz>>-ZjieUNIIwRUB-I z+UZ})-sP9@YFzCSHbvUm1<{e;xU4crR*L@^ER3>z3G$Q1ueO*tZT7EeNFE`J-W04@ z2b&DwK*|a^kQxJ6XvJdvUX`3P2C!l)7G;7Ji)yKSNh{W5#zn1IX97=n7*?!vumo8g ztUF6sv08b=y(%l#IjkWovSN{O)mE%?ViCZhZN=h&*6mba5i7D{or6VOkQJ+B5*KX6 zGA8kG%vcA_$1*U9JwbS{_9iPc)=~6@%8qrPSypZHPm3+WLq)j8XE0^??q4uv@p#3y zEDym{T zVi!7qZmV=QV)JqcKfutZkDSc}`D4ToVOMM~UpI?dx{;kowj6Z@i1n9Nqkl{EDwr)0 zw3g!=wtsibvOXN`WUmxMa5_hir6THXQjLfmtd*B1#x=Vs4RCR@8cYG`<_B?H_pW`(FJ)?zPoafGA-SdOD=mli>cogld$M z=AZpXKI&{TUn(QhMSJVlvEf80tV$dLT}>7-fB4mzKh>^crj*f2tiM_>2tw6*QBQ11 zXy*sl92Se>(up!Q7E4Q`w*u;}x$UqCqa|U3RmjCO{~%nRx6L8Xp#=by#y}$*C{GR; z6=KQhW=`z_6mN4YBQ#vyj$JVkJS)5*@9m%+OfV;E#dKX{CEjuM=XW4B@bxB=y{zcv{!UgE9 zq6B)}qN1mZE}?%$&bW(o%%+)>9)=7awn$IDvt0Xi1$I+rSpjsgFkmqzQCi)Ns%CXV zX^c*yVR{#S3u}S^ec`f_c>y0i4cP#fP`N*=ZhGZoMXvf3F})QcO7X&;-WLnT{?SQE<(SW zPAb4^{utgpySA@+S`=^SZ0K(2O>Nk)VTOMj)~wC>y!3HO^Iycp3h9Oo@rM3}4b$0% z!G_rl*@g}4E?NJ0Y4^7J(J&n2`mFxJMt{z7YCQi?GT6ZLn$+1ox;g!6pl~QBn~Xbd zUjbnBFVgn^>ggX4AJ9#?7dJce(PZ#AMAfU`{Lw$U{hg=(^wocF#2ayY7?=GZJF7@; zn2=Fbv)&5)?%Qwwz+3ZpM8m&xFgg-=g#A+MftFsT8sze)zVp0>gG zv1EWtKo`NNnfK$#V2woYs-cs~fct%YF*KilA{pQ!F;(2-JF8q3K2;pLH+oXE^mr~U z0f0_8RlMh3CV_~?1Jd_~?OF5vTnM?@vfvCICVSPnPbLFhs5`+rmxn%j~7V3!p%m}X!k?lzabEv9J^zZ#wUE+yif6n3=adttJ!)T&>k`JI&N-E(sT}i!wiga8?nk==3s`bP*S?nJ{ zleGYz;M)o`*@Y)ECpFpU`4YgEVoG6g_DE!r@;Abf&V+PM`cz0uQa>5e5o@HDk}w|1 z@c0?maD$@!)2%#h+I2BCTv?}RdiC1j^B=a7``MLfhl?n=zl=h5(UjZ^8Ae;lJ-w1) zETZI=!?-9)t`9@P+l48)UpSAF`=F@xs+HWMwUS#~PK-myNRVrhEvDq+pq~rlZ8V}L zSmTzUCfdLvvZge_lAhF+E~)s6SXYWKp|>l=*ShrryjX(b+m&wG><;beU^!n#+WXbO%4Jx;sr}7^7Txr5;Qu!w!;#%5X4x#o3+Ht_;ulSu#_GpGr?BlwquGBE+Q| z>lC}KK@;W_<2Q#U{M1qt{%l(luAZM>UK4(5seyt;7fBNibdrNN4Q06M&lg=8E>58b zrs#ni(KAklbWZwsNTcQz$3j{Lj3yhvRmjUuvq+)zdErHM)B6m9`pPJwF@N=)FgxVrzaI4iPPA zh$(IrXA(3_Z9aBH1VK9%Q^kE1Q=KXfS4?#wJlB^s1pT>c{qJ3WZgB0X2G^cyaBU`X znFfq+tBbXAUA6Jm3stTkS@f;->#C<;XzJJ1)BkxM{kqD?7Nqp+r@DSUw*yOEl(m#x zXCF-8h3VIm#aE+WPnJcsUyXh}S$tLc^erLS&!b=eQoT>HxPoo*{NZLMtFM^5 zwwM_+TSh_&T6=?u|3fR?CQ)4+rF#(5Dy*KF_?tQjOJtpZTj19c5GDp}E3*Z`DSKgJYK1wPHP%GKS2Z zpW%mkivx`fazEZPZv)kA`- z(8r;+&#+phLC}mcqCbGp;gN4C_crO8y##sp$k9X9kG|kdwDw8N#9{&s*lF$ z(I9v!2PV&C*2`DL%2HgRbC!v`NSt#=qfRQDrZs_sAK*y*LSK+lt4G~p^8PgDUNf00 zL$j`Ww423JPaq#kXv_|UPX0?g*fES)Rx@?e&=z_iqpKYbH>CAhu-ngU57ZT`(wl(( z?ZY$GN!#AIq3X5*QTdQDnHd-aLmrA8tE7+f7jQNgY=h?!)sz9gRB1*RVC>=J-Ex8ec*jlF_9FW947Md?vWeFqQhFM;*DvFs$N0$4%|z>Xh#-k2e|Xpz)e+9Cgwz zTTF40ZkuH-vH1&1$l(Qe64<1*^;Ji#(O<+!~Sgbj+5E;PERoG&k7(* zmStV+8ZJ>5yXevdS*VPPb(&fgt*+T#)gXi4I80@;w9WXz5QnEFhY?@5i2!LR9X$oS z7Ca~WW);uY6?5&hSL`J~B-Ovfa0;(qcVJ?>$E#|xD|NS5)!|l!t+wm#Ru!(UqYF?h z%@W~#axHj2gH&XMvPiZKfyw^^673vbN|XS!p=`J&w-|3)+ZcA(sa8o*cor};>t_Ln zeDQdyyb1sZc5B03*|!k@PI>i!rL+7psgRfaRss^JopE^!H~LZ5jl==u^9o<{fUkOz zJqJ|DhI!c^NOS=b?Z|(H#m7S%RsPyk8!KhieQy<)2?k)jr*XYj=Xux~BbgbVKKkVt z>2*avO4P7i;ID0P$&JJ-wt;EaEE`_(Ox*8E$StUqNM)1MA%Q9Y>}G3#!6?HxZBU`K zMTPR>E#G*K^Sjc}+}7+=%Yd(7FoV>jJ#> zBx4zK?IyfdA0W|-68PKoGEqDa!5~|O8rjZ(3-Wtx&+BW)v zxk!yd+q{NK;zcT12J3xVgoO+0W>a6&q3$i5DWg3QO?T5_-dnR}NOrmHP+#u*Ml<9U zN3<$++wX$rm|T4M0c#Pvz{6b6RCA55z3~D)$?&#aWR!stw#pdc!o1Yk&Kg(>gf_jU zydw@p52B%_T4UcWS6{J3&;^FR5msNn;u#K~Uo;%s$c!~d1-hyt5dmHJHfx^)`&?t6 z>+I7|Dju$FNe37%kz9b;FdWXHyS*A+!{sl8 zvaJd?lh|nmgn8aarjSV52rh^HJ(9XO>JR&;JiUrou{qcY$4UcVlJ% zT=vO0?n%By6O-!4taWS$&ooJXv8C2=9ZXSMAci*xyLM$fMGM>ni884lQINbGoJo;~ zw{>eClKMjSdGWn&chn1>ge!)R-mx1{cnyuS?N zW@>S)IY%w#+f)_8nwoelqk>Kx2L;oWV!V;Dqf3?-+p~EAj;O@UuQb243G-)KwQIzv zf0aUvZ!3FGRwo~Dxu6bno{trLMYPstZ>qS$)K^q+w&KwPw4-rl<55sw$2OPiaV*6@ zQ!|?&+6ujpI!CF=0T_Q2OK8`y1Bo4?kARTGW~0LVms6=18Uu=?2y5uIYxr^q3iPtR zYkOa8cn^4U+5`Q~GZan?3WNjKzA0HMkjrViG>6fF^^|5mR(XlXeipytESgD{Bzl=F zS|osxXc>^ERhF5*TB8ZPBC=RbHVKGM!B+CNv^v?&;uRTgR&G`3iA0q0jqRUK+^8dk zPwiuSf(zpEI#H4FGQ<(4cZpY%kL#wlUn{J5&Q8U@v8tWc$VXdC6nPARC;yo6MhkXm zwAV+WA_B5OLIPMh2BRT$6ZuEL6>$+|#JLz#pJ)}U1Uab(hVI}y%|F~(P)8WpFa=Fg z8XH;wI7k`@rI~P^SK^UmR<>$2S(t#rWT}Nw4E!3M(|Ysn4bj3psI&YxvMgelcX2)Y zU&m$qg4Zv60O0pk<6Lyn`OuIsiZUme_6d zbE7R}l_rNyH&O?HQmA70DM3%ko?J2XDh@bJqR(p~aE?WVEQv58D<*x@9qi1>#3~S` zIa<@a=&)OXcoqyRDxgJ`o$Yv=XE3a|$3CMwDMrAUPw{QkO13aNx~14oh9ja^O(Wjn zn0ZsB6~Q_T>3RN07{y%O6KigYQ+V|{$>MEIv+m&sW*;)>UW2GO3Gex}2_xR`tESz- zh<8w}m8Z+zVP)o32V)M=(0MD4rj9RT#5-cfCX9H$m$jf`&-y)e1^Pg5~#*yOowi)1;?4agb}XXaPY!)hSJShvRXW zVtB!YoAl0@K$~RuuV0Bt?^gfvMbaXYC^yYSy7QHJgi{5Y%i=Lv1 zWkf7$TJ$z=&wu^lS@g8GhYA6Kum5O9M#RM}dbkuEHckRY`;FO<9T6H~mQvt(DJ(-! z;H)yFvZsOP3R$>5fl1B(n;H5jmVaUuhCVvWq4S5)0hM2@2a*7wRV@pf5$JzN z1!N?dC4j7*mW(B|w2_buuKjBd7F+P@41{*8(PB0?s&(TamG;b>xI*J#YhdTWp2=A; zjyyp5H80H-56JACH8juP=n?}KmRqB%8gNOwO2@K@0|;=P)fgEY7C4n;)xu{MF*152 zIN;MZz}cda%>YZF9mEJLQuPG8n}QLz-K}BuE9M{;o8lW= zHpS4ei4oQXSrjqjY9Qs7JySxp~qQxgAsFYN!5&rEG1;_qMWuw>1yT&)%JmC%PK^*;~hK>aIgXA2n&wKto!bMqr^?QG5l^6q(^`5EEj7Ew7Lh`=uj zHB9g}O%2_>h|xM~%V*0dnok-`Ohti8{DLZUFP%E>P$uG&qXJI#iXKg8yiNfX+K?4jHsB25v?*>bmo4G}Nm#~xp zweZFWbjwmkU}){Y$x^0xl^5SwCd#;sy$q3%$d)ltTP>?JmC3+Tn#$O>tW0I3 zWhzT|@ZHHjzO<=~6A(9SmjPCtkvSh5l`SDaFKl8TR9~r?n6Q>8bMLx^2D5+HDp%s!oYrZd z9TEDGzZA!V5{V6+pOi#Tp`T_X)*i7D5I`Tyk8X_1E=tYrM<`KNlNM_JQZLT5KXj}j zh(w0RxHar~fOrfz3JQ5bwjWZ(tKOxx2Nym{h_pbP0+OF;=7Tn^Sn^ zX2@yz$$1<#@(>-a&ZGTaa}ZOIHT*JAM`mN&!_*ZBhB2GR?2~YJ`ou-6> zoF%#6lj15|ag)DA%t;WvlJ70@`G^#14Qr{6`50)psU~^0iPTdS_0v`lYt?S^lJ`Th zgDpOye+DIEiHuk%GaS~`g1D&ep`nqMQf;;B2|6Cpw$^Zi3iF7*2jth-jyxs%9>_1@ zh3(Qid&p>0Ow;@*C*9*H`;NKoo{Lp%VY0_7vOo%FsC%YacZE=f zk;taamlZ~8g~_ZQ!k)c<@h$d*4favQvQW2c@y=vQzvgb?M!ROW&bmcg;EQGTyDeLr z^6&}`p8v~@_ipuMiH-Nx=6c<#ZM?TO^~;(|88czq{abHjP08~kQ`HqcmujN5sl!wh zIBAX^4?kUxFQzTdC6*E1W=#5}xO2!WO?xw!$_^9Dv1?Y2T~O{Qzg@d7+T76 z8h)q6kWG2Z!4#@j8KuQ#b$es|$AVn%j-FARCLNd&tcGeSpimpt4-A4sJ67%6xFc;} zD&M$$4~*z_F%E?Hx;j3M`#lzP0pu-5V~84dsxA1%meF{q=X4Q5F} z+L_uk?u^!@00E-Xm3+KT?s{w8pG@Jl@Q_gexiXAf9ZN}hwZE~>gq<~%QB-xSisZA# zxiSnp&#`=LU0|_^M)Kn|P+ejhR?+a1VXmE$wW#r@7m~E}5*tE{|kx8R0rvHQSXf30_&23T*)6`4u8yh(rl&dP3~D=(5STHftGfz1XQQ zVY30yjdU@tS~h>FwZlt5}#Ko@jv@o(Ofio|`6J+Vqiku1~N9_0d}R)^3S zth2gXfM&NOFLueLb=N?h!=;cHk0k5#su2q?LODIr$rr9~>86i#BZuO?%ayY8(jz>RAe>QmZ&Tg;sI5gj-UJY8CtGd9knKlJ0(U8XIZU zl7a2r-uAm0-jVJ6TE*Q{3$=>7xwYE-do{C5Y85Dc4_~p^15c95P%r5{4DR`*VxgY2 z6$=k8+fXd-Mrv;<7F59C=k4=cs`Od=JcWrTC>F;(DaGPGPYU)&NZxsV#o|c%h$$9F z6f<)PiKwku1mHg`-2&}G%6m{R3}9Q5a{ypVayG5iiz8|N*2UC|cXA5JRhw1n7kfG@ zTR{&;zc|=miGK0=bQB>qJd*mwe$)?h`fckMB9(3ZLQhz=MxYdYj-Th#FRHrBQnh~Z zhHt@q2kXB;^+F`PlJ)$;G`qM`O3v!lixyx^zE%BFFCe#zsTV!=8Hb!80h#%b zZmnonQYBzcD^ev0<*o8fRl>o7Dxo#AoGKxBW}{1OGEGVs07jQk#%_elhnLnh3@;hE z$3QZ?L{D?OyenfK7bq1Ar)j*-i|AGb6Sp3YTA}lcQY)ka(Kgxyome}()YS?L!nXiJ zW@uQN$WV&b_!8L2vTDVpE)%x$lxoE#Ewy6#oKhg$0TIY-&lGkl25~lM?%HBUy zC5qD$YF0y^%6~^_kXAiq30k2P$2?vrph4Lk-!!)FK->G;g)O@y<4t}?cZhfI@5mut zXR~5+!p@$thyejohZRen>?wShE%@I>0>hJHr_2qcasBNNS)_ z$Uue@DDK)+HAY&OdM8NT|97(Ok+}1{Au<1FmPm_-LIVABaY*B};zKhl-$jA6kT<_e z!0uGQ)^;@`9(LpfX`t@b1A)TZ?tM9ss2m9DPC1bK-{&K$2I6zXEzv0Xnj_XnIgrL2 zywq8;>CBLL*1#$5?iT_2N9mFfQBebx+YOEmi)-mvC!H5 zSd6OPat5d)Pu%kbBhZDXo(Oa zyspNxFV=uCDwQJ|f#SufciB{G*4Pmg_qXJqfgVxzXS1xL;{H3>D;4WMM#9nCl8)e( z+;6qyhtm8H(qeP|4s7su#>H#j73DV;58NR#RGhRgZS#-pNB)PYo`HXNr^PJ?LKAyQ zgeH^>O(=Q%{niI1Pp}#FM``{)(&AQr+2egALOCTvIVI0}IVB$`%jNf^#eN&_z4~zaAc{YPg?YR`D?sp=BjQ4NBg8w90U}DtDqRcf2mAWGJVkuk%95`>Jve z@XM+@Ng}kTWGHuve^y0ABw)b|gO^=ROwcW-qYivJ>P@9sWHYN9cpvrK%#DU_@vfP2XoRXoO zk~iOP<&=D=Dt8yZ?D0Vop*+_AcxlA)ZE2R>ot zl$76y_wxk5?D26DVSGx4a!TI%$tr`qP`um&Wx11eIVD3mCHH>H$|-rYDtDS+_V^Tu z(4LZ^oRW7vP-m#hJye!EQ&flC#rJi_+^jJk_hc78OkYn?lV<}2dZ+r zOY%8ilTRf>xjiIrHkqN&)4dGTL2-t>R_M%ck*AM5M8P};5(y8A`4u3Xh*zB zb*y*fv@|iqX;>09o5=82dulbA;AP>xOe)IX(NTyaljikhk)uunM-@5)% zy~P*G1XkA==(xbemxz__td5_Q_6?3EL~;TZcRq8nLLBxj`6SE##8f7RMZs`Na@Y3k zRdw8A?ekgRf|b50AzOoz*~bXhEpMtJyFv>k435Vl$Vjx$|2VbjG6-p`B(zbdS!h0^ zVj!~cfU-U2jYYT$W(5iN^r#eRXoq^kK&g`<`um}^R1S(gQRZEO*{*HckesMFs2$g# z-orkv`u!xzHAymH_nmsJ{oMo2e0P}uX3vgYPABMIc6F4@6*s>QbucR8ok+%{^9K~| zB>(-i*!{X#qMOFCha^9hRF=Q)a7yoW0#Ei6lK;SM(g9+^3N+J5ayfIkBY#(lrxg!y zrC6Ag5LsF)0oaD%;G=#cb>EHa;eU_0SRKrF0g{Bo_EeHTZ2~MBR*Py)X&_tAVfzUO zKTzNn&Y(SR%%JqW#FmZwewjX!--{+l{b~lm)Ns_R=V@*!btC@+TsETYhkWkp1+&<4 zGJINOnd#9){%nQ{^LM85RXh;X3>I6W)9oTCg1%3JIx#e_uLvPqI$R=EqI}($qwV?K zorUuus+Iqdwnn1-e*oV69+4gz=;ZHoXgi>N$bey>1=AY8nzWO7Br!_1r+7IP*eqkqC6sR zwpp-y&*H_hC-9QRek-N^2`_ja;>B6R(F^c;LoY)$gZJzj?RzWBv~*)t=M9pbM> z9R*t@yvugmA)db((lw?FE=LrG2K|m6W&fI5k~#JCn&6W}E!WMmz(otp7+N>2P1l6T z=^5)bQ7wsiT>L;(s@(2kA`7b3g5I}iEgGGbHhZfgJ*C;VYs!7dC;z#cE)k$RB-dPH zu(2W4SWO5(A-CG}1s-N-}UTG*^|TYY`y@vjn4qi+ZMbVHC)0p z_~}2c7!Xl0FL-}Mx&xiaenbX8q_)cbh((@ylO0Gs{s#Lg^9rTVS|K%nW{|oT6Qzd} z(TXJ84bMg~@6Bx~_9^^5o5ByLus^SChRTvr2u3mN%fk#Cyhyy9cZCAFAKjkdTWq}! zV@T%``@p3v22F5qY6Kxq7V=m>1sWTrs>cqg!E!~~ z41+A{M*7fWPPK7|(X{R$(_8ZDQcxMycOZ1|7!ukCT=-r^BQ9^VSL10$qlG)IxW)n= z&VUSCc;xKgjArr`k^~Oa1pBg2>I|-84tc=kke4aVprPnp^!S<)aXURU)NmSVYIgpv zQPcmxg7$e;3@AV@k$H*mzsF**Lr@q;$WVvBF8+aR;pyV^%VO|O;f6QSO{9H~!vv*z zUe$(VXE0N3m}NT!74uihb%Ke>H&eZ4Ze`WGAWHS`NUJE=(@WzfFn8Ppu70j#A#UnA z;Wlngm$+HtWrdZ@Y}ZheQOhRzxpX|k*sI%bsv@=sOxC)iUj{<^&GW;48~y&z z3N<|THBcMiunJ%l)LN(^zYx%ZVRZ5j2my7VXk{2u-IKB!B>$reMDkb1)ljsOe0~t= z64t?>Nhu)N+Y7}Yy^M)qxu9-oaExllbv(4}MC)b4Mk10(ML8d1@fb}HT-v!GqypFk zQX#>MfKO`B2sjR%bO~qJ7_>G#doYCu?*gLY+7V(`EZHi`&rtEU?Ek7{%$NbtH`kt- z3yIg7i^wU3L{OJ5RnrP5!x;@-eE#{HDG)sZeW8Bh+OE1CWX&G~e(4-T2X{pOIp&Cq zHw$q}3(+u&MaVF<0{=F}ky9%$Nsy0+{Sg$NKoGhp3_{JKBR^kGkh|ITYOZ~U1;KlO zyacGU$s z(~Ow{L>TtC*L+M!wy)od{GJ#@`Gtr~CwWbjEMZ0uuiIxqB(U4r<5y5hBDUn}cJ z$SRHOS+gEs-LV`zFM2l?hvVyo?0%qo9EE!H@)*mjb1@53lC^90z}&E(I}4E1g(4l|dHHmWLnYs1u}D?&`*)HP*?4;~e=xmXv#o2I zeIauUPRo7RXN?`w%Yf9K?dHuHVpdpQA^0#F#@9-8M`jnI7fD7KK^KMoKFz+A62Emw zXlO&r-Y^kHqJi3%5K+-vMV_%N(M>k^I~6WU(C8GxK3GGAeW}r48W8q%D@aPBV5&PM z_EjVb(qiW+v@AMBiFnjvl$Tm`a#xkXKRX~D7{&KVi-+B)5Q@3VO!#ag91ywLMKfu=m{yo z`dI1rP0x{DT(Ii)V4l5glHmwK}RTwAa(3dC%U!@W-$qA<_qGX)V ze^#8ZZoSP3iH^PTK((s-(7Q&>KlY)aVC6MeQo#66Re5D%alMqC6n=;q2fl~JcfxRqCA zFnweg)#B_4gf{M{hC|~IgFQ{xlh|M-a2nucD`C2v&}CWFa%>4y4t1f(22@_an#3q& z^no#8neuoq#+n{4(bhexNT3L7&oXj5^3Qj)FUmKlATt z_YW`w#GiM{AC%*VHY1CZ@5Xgc_=bld$yb2)m2PfZWy2WD;``$K1md{wh*`OFb-CT| zv2tsu!!qB|%|Fn|o)RVO6F2t%NQX`7y~r@y=G$-Ee0r{JJ|3YNWFL!ZpQ4A}Q154x zF1HT%$D;_ADrZ&z1P|riHM3Dxd?d>EclFCEqweC=-$eNjk~cK8hjG(8v4c+>>isW;X@BOQQ7 znF*lr&Vcq&1DbNGGV&FN>E&xX#Zi(cJb9etSx-Jda^L4H!x`oENZ$OQ zledvP>dAv7&v^1~lJj4*y!VmZ z>&g2`?)T(LlA#Z$Ngnj4XGtFR8SW7c2gR9)mN4mfvG};P zqBm-V=kRQOiR(MBxU*3M=}^OdYB*qAxj1Q6=#{GAg{t7os<2Mn-Kc_esNx`19JNk- z!fMbP)xdMrz*pUgqm3F!hZ+u3!*TD#C#?#-QWd;V6@1m5IMJwrbg1GORh+X5JdSE_;+s)8@8!o0)&yGd~y5vH`S^76@( z8vh>Cs_!D%)&){N`nh&bq^NV<>%;X~m^LXc|NTz(Z%a==y!!9ZS}8r${1k%G4MUlR)~5t2rc73|T? zn*BsCsfVI!z=xgvBr_#!!3op6ssmcN$0Lnnf59;j<=~E(k^Y>#8m&tt-P;6!Qo7N*kje(&iZ$bzAqc%oHRl0x=D3sI)JmzK_is>4QXo zL;894RPFHb&R>j^B7Twfj@1>+0bm`Tx9m3?8btD?WaA){ui&@)!bHDoVRgXw`t}%i z?Vuu%H2)|y57Q^5?zXNJj@P=vNgIyY4**9;-^w3EE-iG!cO}?HMFouVp8*_a_X+$lM?iu6>~=`PIMoV~3T-%VUo--U zKz^H!?M$;;e3BYW)FF$#3TCTYvM&qgY13aajLpg zO|R;p9JT=ZN5DneE~^i3Lkl6aYpbDYZpC@X$lJ53sbopgHta(orwo2VCia=NuHDUE z5YZ1B&_^df1}O+@>%YYnEn!Q&_-V{UcG5p7X0)kGXNl>nK6)KVk^P|DBS5I)h3wD( z4*;RBY}=-8F@pgVXPEpDaMnmMSYh9qpTFsP?~h=PO-q2zuf@CsMb=q;z|#rQRek>* zI`=;49PXTu{18hERB455&EDJUdO~MIUR!XjFv2q#eYBDBu34jlhPUjLXs&TXrE7`; zwn*n1O&DYtOn{2w9($5zhUpHi`DQbok0;qUDg+kjN&Z1V;ls_|n^f$%4~fNd?q`ah z=3uDiVxp?hV?6eD6@M+xJ;a-O4$meyjrfaFoOgyJG!GH?#T;gY0DW;C#l^gKGzdsA z#AZ1h$P1BGlKo)Tm|z`E6{hnQCYWIs|JkN_hH1t{q(ke9mfy**Wz*7r5Qbxl7~1@1 zSDJgZhGtl1W+OVn*a=It1c%s*4e|i8nHM$t_!+cHj&ffecZuP*ZYI z=o@(pIP+93#tE1;zz^WXj)C!z%QQaJkz)sQ@fRJTQ_0=MRYgt8Iixy}&jqEOz(a`c z$IzFUWH6k|mkbrk_T-O{>=2L9wP-^fxGt-wAz*L#lZ_cy%(r@k4 zv2#0if|zNEm>!P1fs(y8O5$C@e@@CA&;jLe6*6q0gILtTrZ-DY_=}o60iwn%EQU>E zMG9!)Ljz}1hppI!NfS+^E768f^2Wa)tD>jlWE3}=6aq<_bsA+i< ztWc|xRt4nx<9b{{_5cr)Iscm&!`R%P8Y^eaS^HSNOf#bn{}3G+%vdBqS5wed!McP3 ze;DtUQC!w$?{sPm?gH{#H-*R)hk|NX)3QTLAPZxdbU zkwQW9MO<9L%F_bW+5%=)QOpCatF`d#H`b#UzkEKKaAWCl%LUY)q_@M{QQAm#iLMjW;&U(5Cl-wo>T9*ItDu}tr0#j^dacU4*Sel+|Z3TLMq#j+M=aL=g{I4P%ENGBs zX?h+*&*Pe&W2|h^^N(K`Jr~IbVMWpdp@XEmDj~g8I2}m(o%JYcx*TraWUaU^<5a$+ z%Tz78EJf===(6}J>(FSUSme<*ZG>RjR4huNQRIHv6}dVLkyw#>W0W%dwkYXk3h4MB}0+F=9D>y5VNs!Gy0|^q*>C!a zwa++2LD<*QZ`3RnbIi5n^!lG!uMxE{=YTY+ve<~hEbzw0LPF*vAu2$ido;X$9S8Bq zDWDGNIR^?vk+d?Dw~=$>I!@rsQ8ziaa>Pt7rzAIf*)1yT$;<2Hm356?zxW}kE5TpB z$SEINQWQ68L~^4q0s~c&{Ww!80OjMfGCW<*7!X`G^2NaNwV67_K?W@%$`^?$^(;aS zA@Egvg(763UF6Zrv+Od)uI2$H$f3T8nCE}j$+GWR>Xl;~OVTsj?D_oL$!Pt?j%$yV z2lNx}x>IRi$L=A*JMFhjs3@U)qR(-WM}hvy+TPTx@`a{NEZRr!$UtqeB*&(u(fKb+ zE2W-iv4Z4UnsPCbvTOu1QXmw@_+`-Ris&jMB0&FV$!)7~QoN z_2|iZz&-G-nZSrt&ICiS2_+XZZ?j;)r>6k6oF7o#(=vc_r;z5mE|E+WET>Ods(HJ+ zBbv@om^x$$O&z`ESLiLN&7dCr1~0BkHbWpa8s%W1WquY9!wD$4UgH$zt9>miP-|!% zr-Gq!ZY?^>8-PuB1_oP57!mvCQuTl%U-IB$c|ARTGQWgQ42UMb8o(Wq3%GwT2%zsL zi+-`@sh;rq+h)Oy(G>s8*PBx}5PJOe^l;cC8*BjgBCrR)GpXI-z#Fd${I*d&FUvUj zdR4Mj!`LaeT6$n4L@lt$K>IC90!dAeHEYX-@v=%vl#*{~jZ$>~f6B`~pcLMspp>$J zQeDOaC|C}3R(MfWo`GzJVR9_Bb>;P#xq!nULN^nBG$6CahTL9*0>CX*&MdQK^(7?{ zdf9jYBLiQmEGT}RttpU&t(g9c04)QEv{sodJc?!O7jfiJ6Q6jfgA@q&tWH3{>cslb zb0?kIwN+h=>qUY}Sr=NPYO+P%^O|t64(q&YH93`F>LIP!%W085e4{X0cxX6ntHcqO zzL#{(u(mN!Ls~(&U^#3x)CJvioEO=QCl`ikWouX;Lt6%l>~;~M3x@@Zi{UN3yg`|I zd587kt6Xh{W#Ry`g<@SXzCy|tN;T~4R}(vF;GOL@xCq#OR;Ej>cE_;+=mBYfv>NMe=01 z76R2UQlit>qC6EH5ry!%r)$mTz476cn)k*znIQ*ZsLr@IoHk}b5zcJkNE=;agF;y? ze?2*SS~Z1>L8XCeHsl7X;S4eilfR&3mL2=9cn}OH0~t;h{{touNuelC`o7atLAaJ8 z+g{wHb12!hn>fOe-Z+kKM5s=88eU`0$1oUSmIJK3-uqT#&18Vi(vZzCcJgkqhd1M{ zL{Dl50xuaRKfBXax#Enqhy17$hnyA{`{8IYuvM*mu*(7~fDRxDFhvl2JsHf3pr7*2 z_VLJ-wKAE5=0qxm1hM0KN<}y5JRIQJArm(wi~Zmmi=2lVNcYB~zY`N&q^t>}D>&WO z**T7{7d-Vlz7e|9{>^367Jj~5*1Gvk>B8v z%-J9JyJ$OS%DP(g!C&f_|JpOQ7x?Rd=&THe$B}|3*b^Z-YX$t8pI>WFKy@I#_C`VK z`eAZC9s}%Xh<_K4+s+|T&V6o%aH^w?nMtIL7m@9X>x*7Q#kY|szHtYiPuRBUhEZHj zS2;6&&JnP1AZm=3NkOK{js(-X%_czvgp0+uYfXX!$kE#n^|@(_HsC7Ms$FO8Ru9wb zh2RJrI!VW{S^OF>avy!y??+ax9(3;o7MH%SZ>h1KEj^IaU!nq)CzMvB(B= z1^z+;of)ToarX#|KP10A-5xL<@@BpcUwYzUq+2 z*F<=(o9&g|7K}o-S>XYH(aDA!Ayqjw$1I{#4dC{OOpuD503p-^o3ak6i?pUbqw5VB zko3|n!Lo-_x(`ngVjvzq8(@SE7hm9q=9*f_&j{s`A&PosYT5l|L7VPFlH4krR+GkZXI`kMn5RQM12JH!xw!U z12*nfWkKV}N?i^pfl2hAoVQrzLSIr^z#4XQe$n5n`6Yv<3NZ#S;gusrkR;TAnMLyp z6k;3+E;#jV5~)P&5}UUn5`B?YB%P>EdtA)Fm2T_FZW505`gLc(+7y_&d?wk4;hTtO zB1ux*qDPj7eTa1p%}rPLSw z1<9{C#~QxR07QPBKSDSkz~4lx{FX%MtuaoBjIRH}i=IlM$!!06tBS5+ts=b|U7&A) zZfF*OAFPks1+UOPbuQYz#HbR&irZd6c8HmRcS5wp=gOzhKLMc4lEpa_ zswoZ=+|d&DdDg0AkYN$SHzWC8(P8zPKTyHPPVa770BwoyI zBWNF+bkf6yx>nR6shA0ZRtYhHXuy(%!-aDVJn#b*66Lo-BIV9Bq&Kt+(QCYD^vslG z;WE-c_hnK82!{AG!_t>Gf}p_S>jMIEG-Tgvq(<;&fTTdPC>#2xW%`m~*EJ5%g;Flx zf^QaTj2s(BQWRq^JSD4@Rn#9R26C7Ch}xopNF`oSCB!NfZfD#Ltg`wA(NGWpCR!V% zU1(b~EBckJjQE4(Dk=)1p>rAz383uCW*`s*EsL=xNPyCs;wfAN5yFE&SZh>_j}6db zy|zPfk=?clLTUL;G`5=rH)@m!Q&eU{(M_V{*~pwph?eQqUtr-YUkqo=!Bb!K(csi6 zUV;vXnX8=jVKsp~@mYdKn8FxT6KyR7{SxLsMEW#KmMJEzc~eY$e~;PCMzLxH)U?MJ zp`3&r`U1)O^0#<`g!;C~ORY_jw-j(|kynn3!?Y>#qBtS)s(r-B9gu%SUKUbQxs?o zFgMUhg7PqyE@2`h5$IUvNWj2?+&4%@re}!5!UrTsVGe#|+G~Mt+az+Ck3&hI6Zt`LzdDOUx28Zb1V#Chul_?{f9(%&A0b1YUl|u2R+dm>9yMEd-J*@qqB9w9Law-dIuzx85$`GP)m3JZm0Rze9|rOJc@9V=6m#hJABZYn82hva?1n@0&S)f)C?!j{-0 zM#T|wY?)N+1JUfFtq&n*dwm!Ssi=50W1`|fj;$gyA2wDRkz2jTY$1bjXgg3&Zpt!hCE>G_aw*Usi+!>H`S39#<-&Z;{J z4R&?Ns!?-XAB;ST)=*-jVs?2y+<4>_O-i|jT41XPw4qdOIl@v$M|InQhT?X+m`vcl z!ZYC`GJ0l_)JK*LqL+C8S)&M?6kQCs$uikWNNwOC^v_ zNx3!@Nx2QuDYs*PAt_fcw7PLI(-6=)2)5@q0CvD07>NrMn(0z7Vv|#E*|K8SLe_{- z+`JVSo&1hu5AFs&quG)sszoJc6xdUx3e|O2xGTKL zLks)jco-`8=G!XQ0%YvAFiie_7XcXs3hU1WAR`#pK*sI@J`PdesFAtKHGzyg4=R_v zD3MXDc>$u;B!XqZY}eSg40cM{xERV9Y|Ka`GYPhZT`Tk1W?l)n^aQXcbz%1cR5GN( zrbc+s~5JJ*7te7Wu;^Qi!MQFsYr28(A;o?4~r7pz7*AX^|WsC z57?#s3~d7JYf zS@e&2mDK}a;0aVav>0W=$0r0;c6_Z2e@XTx8Bfd^OsTvZs4SBzA&ze8O@#D>J!Q$* z^)-^6)jx0eV+K&S?4<<}n|=DVFL4snYi#%7(zO##Bq)#4nP78%I%d<92VVMOIV3P4 z{ayppul+<)izal0eC3Xoqt#duAPOaV-mg6Lgcoy%_7~NTGtkAf)A>Pq$jet^*p2GZyBTZSpcz*<|G>HEHF9yz=2zlQ+;9 zNX#&`5TL1=aEwZ+pdyu;IkQZ7@Lv6^mb05GhH~3yzPohUZPL$%mL{3vzBN`2YYy8G^%BO<8dwsX&(Gu<#QJzi6nQ z4K=HVlUFn>-4RpP(tTTgYdV%4Q1smyDKlwW>bsM%M5Dawr2J^BX4p4b;=3!;L;}&| z$5xRNq3Nt}(}~2ipR5}4pks(nCK5}~MB)>w{cBVE9I^BJmlI)*F6j*&s)|Xe4s^NIgT5|T#YI|`I|e!a?|$S8>E~4m}D>SlQqc! zD_e!6q-ChzRHk2yKrSyAMztAt^il9c%?ulFurVF6s+;UP?{ChZV$L??2NSzF;ZsI7wL#)G$rd0DL9T9jPkY*x39$Xa~iQe|5}}>G;bD1 zeN`(Pvg&Vd6_AG!OZ+qrX`>-6L5Jp*pmB)ECA%NRb%-=BiY=3@LnLE<9l``alFepG zv9VVjQcgTl=28#Kh<9gZ6Sv@DR;(p$p~XEObdh ztDi9?Bnw@*Z1$5ZrtuaS$!DglidPUYTU(?egorYnjjLDE5tCU0i2BX4U9-)mz^91`PuRaT;3TiAlJ=%GN1 z7dLvcG4jnZqoPj+TD%c1LC3yeqX#{twTxb1!L3Fj>2DhPwzeR_uPvxBairsx!6||S zm7H)&H+P1&dvFM$(9c|3h>A#S3-n?^YP{4@h}uF$Yi&{NF#JoaG9y+NU_NtYft}~a zR63Gbvg0p=3Aoa;er3T3K)curdNSHAw3UU46Zw7QFHBb!8FQeh0=a?x z%7WqRImJz1LjheSGmAx{Q^ix~7Zz3`VQpm?Zc-OLdZ$(v%FpYe^|+WEQAlfs_rt`d z88*#e&Tvuq;3ylNp4kH11Dj z*%HcP@7EH^FTaVSyNM{BK@-EUf>%_5;}3@4UEpSkEPQ8rp^4Tzxhf0L&7CVZ?iQ*kJJ&_5r>mv!P# zL66?MKOz1AA$IWwD~sRS!Y`Wq!(6e@!D39B@*3{+#@qK!ddtkY<6lAc4fS)&D<)Ku zB~-SWNx7-h&N=^r8NQ6m%qqKdZbfEp)!ez&bLK{KFPS)b%G`6$n||TkFuv;)9e_cC z`BQQ2#9G#&sEW$HHPPs#NJ+n|q>GD5_`&1w+KCq{>Agz2Xmrv=O8SVB-he@~G*eS^ zK^T8ROaqM~rqxYsdSTLmS}aJOlZ29)$VjFcV_{;`Pl#t;%l)AinDp3>d7LDOLgFSi z{iDiQn$GXyn`W}ovuK>;DkCBj|Il4Cae5RsJ@0O>Ip3O3}yxwFd?(<3AZ>0+p%@`9L5KQ@pP{euCpQo8N zh$a@|4-XDvH%Xt@P2evAa1DnprB~Ui{Dys=urmIt-Stg}2sD8`auV>d2VP&qOvay6 zj+Z0&k9AmIA1klpkP*qVGY4!#i09xOZMA=T|B#EX-#e)y$OIW!hgSov=7FdXU+}=t zxa6yMJW{hPb0D54{e_oc-a6z)gNwrj2kO7Z?~29dRv8xhC;p z5u>Bd91!*EWmw!GrM9n*v0}yQc%S{gx{1-msG602H9D`F&yVu0YaTw%t}^z^)uscN zs-+H8@X-#3Q&}ZFiIYzVCvdEiVZcF>1JMLK%pRHt5(NO)q&sPzIp*}pjvjpuuqz}H zre=i%MT=cWUPehG3y77CgDS*H=0mw&NhLki*!|+7Ft4Yc<-SQdEtSk|ff$EZ#kAmJ(#^WSlppuNYV@&l|o&?O}2?k%^LvAlf_aWJDV9{ePX!O4IC&freF(fu|;Yia}4TB)b= zmS)P-V@oqkTHrF<$Q~6re!$prya_x94{$K**i3E{npPe>a3K6vl^AM-}3wwR%U$I~@re`M!9F}%L`8JVmXn(?_5 zjpZj!dl_Cfz9W*$8jR47Mt)h9FnggYvhf!aw7lg6EV5&K?*9=&hHB|fHhG=%i<7oL@Pg%m~*FUmE_`!2`yd==Q2n?ZxL zAFC)#He&>3aOg+SZFs=?YaS9?C`rt$= zZZShzyrGNYW^rxkGq}GLc!EG@?t|rU1HqHOPO&d=<_ora??e0|zk;}zTyaGwhnMSE z*T8s67Kr1_Ek9vuMck}Gb7(KkfXZrlQ#sX%Q-`t7!pXBy8N^01>E%mw6XFaj5Cc*8 zT@L7T>PS0yl(xvTORyeSN&k*1v>d zHXUW^DEEPK8frh*O_V^JD9{Fe5r$1ZTvT+CL$AMR(Hg1@2r|&iZ2IsKcxgCk0dBHn zZqKkZHC8HDUAdT9L?zZ@uD{VZ6ajtQ&?f$;z7n70zN6K|XO>NGIvgvoEiKC=E;|S&S(HeY$Z( zQBA$RD0X7Gjr8<;cf-^Rm4;Bc6a$oSC|@*$A2L&u@sY?BvnB2V(T^>Yb=WeA-RJ96 zVKT$P+(&tGb!KO3qb7w`NM?q!TCSCy%=Wc`CgSmPSr&~$@b8PVGs3R~+F30rMbFqL z%8i6%jl2r>d>+?8nIpIQ)fhvL*!Py#M83<@B;ka3zpo*hOwmzo60KLI4oCBr11TlK^(j?Gy}>Cn;x@yR!T%e#x>o0 z=s+F(X*!lYREO!3J$Ty#jDU*=qKXF)(@1@W?&HjiOf3v6zo)GpK){stWT0;_X5!-+ z?lDFN;iqrYXWCe;>BnOSll8#!tQ*nQ7J2WXy`j8Zu{9(UXKrTTWYk)sB@wPk%{fT3 zrgt(%f8aVf`vw*J5<9DD@S#6Hkv$L&@KN7PVkF|z;(<{efI|kF0$7fNEY#M5HiIzbl#QdHE)=f zVbnpnthnR=0}4R0XkJG?+%px4WMMg%2ceDx7n(!wNgJa_KWn;0^T2y7SQ}(5NHxfS zaRGL1PQ($RtwW3to2-`c@?@1tN+O1okQ`7}{Q)A6K5~-wS69&SIwkxjz94qC-XmM< z;)qF3RYhVRiQe(aM2?5@fY!B1Lju^UaD42u5>VX|GcKhv%L7niy?N|%cj|lu3KFqa zc2uTeSG#4eWQ}mMJ!rGlS|&s!$dIA-dn*`0=8qd>DmAUsaCS5PhWj!RPk_A!;!NJ|LQ4*LrNb{<0 z)3Dh7@NIQrle>ZHamYm3+v>^=Z#7yX<9kV4XZyBBv=xgZYzmIR&8v?d7Q3s9zrxyT zqJtweN{jJ2)rmmbIyS=!yrf>*xs9r-afN{bw~w#B$z4b9+XIv%nZ4W-(BPR}Y&!ZG zEiY1PIaDKc%qa~|0Vg{M9ENpCKe+9t<0~ zkU`>vJtQ63!v76^5sv2Ychdm!l1|)tQSm$;gQ4c=xKY# z8%@iWf6PQdbF+uH+HQjaVR%Owx+u!TgJpKui7GO=_mpe#Y2wC9W7F(7s!?4bwOf4 zff_|$`H&sIus9YS`lbS@xD|CSfKW~jMhi{THl>Al6WnwknrVmpln+%L`M6oUjm(E; z>jh0#V!qz9V>ZKQ`)b4k4BmD@@q zWbaJy84r}k%cRjuY>;4pk6_aC)B@>xgU#)C9Iov2E@U$5Ia^5vEQ2#P&mkOEngS94 zyUFs|pCo5^*I}CR0;^uXbRLqMcCNW4?-N95Vq9uO(9jtBC<*N;hT2n9>ZhCH>3wy) zH#HMS!W%qXSKbsIiOLUS<}qc_yRew~=JG5LM(V}^N8R*X7dJ|<6;LY?xKZu782P4i zT=<;~#tTY;@67TV z-PdLUW7%QO_@RdYQZK7`@Zjav>v()|hCQ{*h_ap`F~ODf1(EPr2i3`~j0i0YIcSta z&~uY5MiV_eR!JtqW|c(JxgnZS^Vw6^nF=AU-7C%Bv&RVJFU)5b^+=7aMMhY`}2J#ZGH6 ztY$bZS85gmGs~JY_W*tpi=s{PU6=3ky+hxq-R$;EDf8!RGV|TFEC#Umu-c>sg4#0J z#KA||fQqweNkb3ehhM{9C`2v6grZ;|LKh2YwLi+5BBEyR2q#K1!zdCptS2S^tf}Ufj3M@gbR2%!lkGJ!rdyX_)tl$W@k!!RjZCpgTM!HbhKOnN=Bz znE=8(=(T1{4r!CR1@8O9V(K#Wx-H%V27%XBNKGAW?Prvoe)(6o?B%n`=z;y(v5_KKv!Bi-ySKS>&tg^7xI0*efdI5TWfz|=l zXV>iO^1D0w$vh{z^2(^eEnKv45t(=AySf(j_xIf+*au8XwUmfxAx_GTl?}&uCM17rK=HVl6Ff+dtuLTYD-I3$-FHSjmHr&PDX}c5UW_J&CcFti1 zIw_2&xN0|L$`sOFx&Am;r9Ywm=$hgtSCgKtp5Ovk6%t=n!Jp7osEkU+KbXYUvt_pY z)yfZ6Dy>p-bC3 z`*LBB163}(XtHAMPgPDq$6x+WB{X&FRCc{{;iUA3rB}K5&M9F4CGVROo(p|WL{fpL z-4ppZIiTcgQ^K$3#-`FWG%jAU^s;4_FTWygTD@lNx&;k8<~8hqvkMyb&uiEp!QhVW zU2enXb*{U$+ii|FyM?Of7gsyihSJ!FfE5ZIUHRFoo42gKwq?_n&0Dr_*}P%(oM=~T zM`ylWnYj)_k@`YJibRnkj))&>w_2?}P$SO)rUB;y=K;EgD0Dve>A(fRg}@A8Ch!K} zBH&^m0&0Oe;1XaKPzmVz1vu)tU#c)`b_3$x$ZtH{?j!_052X25LF63b=a%GG+&q5I z2h^BpK$*f^M@eJOFb16hzd&(|h-(m#cTGwDlcY5gzZgjKD{cwDmjXAEw*csRjQeHW zmjN9;{Vh9N`|~SSv~}iN``qSjg(WR5sHG%+EqR`LlXLecWlwRxoVevclJ^SAceJ%o zVnf^JZ7q$BZF^eL)P1cT1!C56k@qEVoTRMk*0ly+UBMl@dJH_boPp<-5D?Ca4 zjhA@>`U`#e)~=lcyUs#}wPh>i$1OX4)mHXBC1sZ+4fhp~U+dPD&OJ#vT>&5-W?wpe zI;CM0o^dG<9zXUx9`SGtJUy?5o*l@BuCvgS;yEil_m$vD={dTJu@f759JhX~GQ=Ix zwys5*Bufq8l^z)AP7DuB2iYB+`Dj;9U({b{?QU=F zYmaO`0;jI0DWh?}29QjSH}2Pwb`7u|NXPwHv>=m4%NM~bouX?cN=UkC1F#Vgdq_6j zbS?L>bW=0&n}D>AMr$vVW7=TS)aD4>YO}8U39Buefh|C3Tek9hEFJb{;;#e7tVfOE zQawk(t@fa-JGwgxx0<#l?VE*;^x0k8?lxdAanf^vq4bKJ?dL{p$4T_ka2HX@1&8)N8w3kja+mpkh^0t~#ulIB9Zj z%G7hFoqOK-(=WJi#>_Wdba7N$cZtvNO6jky`rmqP+EX?mTT!0y16yPWRt_--3=ua} z0ZagxLxzy4A^5Fs8A7IpBy#E|=DQ(eYKZx6i1}`a`EH2$Ziq27#C$h|j118aL(FqS z$jHzPfO&3+d2R?98DgFrqWaIF2ToA`3F<#V{U@mZ1ofYw{u9)Hg8ENT{|V|pLH#GF z|6A05g8EM&dS&pIY_--AnoQBE)JwUcK=8?dujS=b%Dem?^_n zI$0N1G_P)no10zyTwVA!!mGF6u+@Z;@aF3`t-Wr;YUc=V->}J|6<)oixjEj>Pr}#> zYq!VO-C*Ih+qT8mtlj3CM3(6fWk3LYYz9hz&v0+umD&HECL#U)GA6XA!#I8K9>W_fz%2?@i`_~cO`HY zkj_}8GgCTqtRwvzKr_S!U?XrX&w&ibZv}P$Hvn$~-VVG2 zcqi~Kpar-Q__wP6-%-~A;5OhOaEQ|(%fiecUz|PsrvEPot`(l_1lj=2dU;?Mup8I| zbO3vSeLyGB1#|;FKrf(Kun*`53cvtxGjI#AAGj5GH!z+Y{9DyOh8zr@aN#$D;pJWH z&bIdaF2BgzzhmBl-mM)Qx;MM}UK-v>+na4^!~#j}cJ&)p)Nfi*zb&fotzS=2ak?~+ z#Uu?>g~ik~EM_Q9gJVGwR^BwMyh_*LTakn}m4r3eq9opkNWvPh!};Uqo^avgWkNJE zVK|cz)i>`dS=+k$g$+b773r#+JyHS`w}-e?5+oI`Bn>Ka5_OhJh02U28EMZb|9#Yv zj#TA81PlVV19t#-0=k|c-(l{*11R4S;CF$ez`qB64=D5vl2A#eMR4EM+S#wL zBwZ4ywn&20^!lzv_3ex5)nBjJp_WGyfH0)_*Ap1-km0ap5YE=9erHtQ9+~Kv6iFtm zF3}SuVU5f*Ea6DQXTzW7F@%&U5!BZpT=9cnbKx`9CuceL`yhD_AVw!f_AF?@IK%e@Q1+rfxCdafe!#51U>}Z1AG`r>bb0~ zaBFXVgRJ<}yl=25TisK!7V(RzON+>eyDm-ZqFeX%#Obc z9|!IO{sWNIc6nP*d%o@F!iKiCM%FJ~J6VAhaQK$cvpC6;Qsim+3U!I5`?%{WrRiDX zQkr&L>S_7}c|_AEf%}0!2L1$i0C*7iQ(!brYx>V1%IaJSPF>^G`BYNpL*!ANp8}2p z4+H-Z_%!ec@EPEYIy=U$^TAiBa}|m}y#FllD(l1p+S1+Hhwr(i(9<$d*tL8^bJvo^ z!;Y7k;8a_5-Iw719N|}s|MHd=JgfQcmR)^4U85?HJReB#kLJNGXR^Tfew_Te#^QT| zBONy_EgfCGYsss6UZkAlb-13+PNYmuCQF|-d+hXdp}urvdNO8I+RNZ}(sh;6m5z&~ z&gI<$UA+U{Z3wy*^9$yYc!%?pEUJ$ud4zv9;YYdu8K6G+Jn)}@#{gaHN&nB>{~S>I z7l1DUj{~}%pW|iZON5pFWnc*SFThuT6TlO|SAo9({t|c+_!^M%j&{i1>b+K1u!E8~ z&ssXzOVRetc>b*65q$+>mtq-?ZCqN6PDi?Q&qL6xaeg;lK9dV-8Yw`%HMY3_k;W9`4&AxNww%Zz;}V~0skHNAHcJ~-vHkS zN?XAeRnl)gucO}#%W&J$ej~cH-*!Q#^$&MlYUN-OR(wqoE^Xz}c|5xC9T$En*fZa^ z@_$lFt$Ysn0r0|uhh!nzFH1Fx<Eubv`F0 zzvse_gnJg?_KFY69}vy}@*|W17O~!qP9M-_Hd2W)@JggZT$t|N@%PC)Yj_J^uEqP*qC+>cr^cr#_uIG-Yq(~ zO2^cTCA95dgu4ZLY7*Kejz!yVGIXd@JZb>HuJP)xY4D?ZQd0k9?m2+7#cnEa4loTk z7dQ_%A4vMTv7xJ{JAZ33g*NYOkd-nrE!94rCoe#YXgWCtO=Zv_8g&gOG)<>2_16X5 zF9c=)Gl4e%7XcRo5l{<^thY#0qi9l{?cmf^%7@ZAUrOq%1DEQ&g!?R@9=H^EBQP77 z1Iz{H0b|v9OTq`$`Q2Bjb5En^{d{n#&IQ~T0*inKpb=OMECH4RmjUC{S!`!BICYKJ z&YH!(&Sl_IotJZ8K8*JY>(bY&$ZXjl+3<+y0vi+m0Bz#S{bSL%m}f(uM?(jXBotne zP`HBoo5rN@b*Pw;6c#nhd#PI#uIH|+l#35S;nRO73b!xuJY1PjcqR9%&Y6xL7KJa2L1FU}UY7UwqVN|9g;ysOuHqh#N#SpzT2dJtL1B@H&mb-{hdSJs?^?GB&@IG=DyxRuYpuE*>>apAQfqcJyzBS+8?L*u54D?yl zI*u8UvaPi+&}V^xZk2KrQFcd0M;>KR8@2%hKsV41v;wyRx;6nlz*uS9iC4Ki&<~6* z`_?2)@hU%FKH=E|2v;947Or(knsmwNdPKiyR%22eW93QPNVXB}((lr?=yxgYX?jYd zewWgt-=#F@_r})lf!4lT-MakFJ_~GW?Q7fP;@-ZFPPd89**MUh=MSg1;(^@*{ROuz z-&@Fc?acSNEp3G!-8c8#>?79X+k615!U%#sp%N0|5DJx7NtJRG5DkF%BHpX*3X8vK z->MDjlbuQYSb5a{X*uB(4|K&qFCcvClTJWanm?^WG^Bi2UAodZl}YmnpYrWa?verZ zr!MhUWmTWz6z&2u_Um_PJN3J?UHVtXQF=sJ)h1}zl#~zaDdJULR}H^2+}{k2>kLn0 zV`tB94pZgv=JlCx=~PMnRZ0GB!}%9?=DT+n_9O+sr8?#V!cG113b$~OLqo{;+f4js zEk4@z?{D4NadV@*hy8mxx>|}^*D9~@v;*%rBR}52w$9f6{*eWg|8C$YpzAU2+oAJ% z;4Q#gfgQjNz}tYg1G-i+|0>@*fYN;LrHUS+g5Mb;QRpw_L}wDvGATOGy1p_^KU%ckDerw*=F2{ z;{VN5<&{po-;3dd@b;+w23OqrNw;Q3Y@o0TO1FlFHxAS7oFa;n-5~d_x8HihJNeta z`JL|8e821NVY{!0q<(R`tG{7Eeb<8ecFr64oy01C*M8Ex`p!=5g!*|47k9STFH~+< z-!NB^@$;u#xM=YEv)$m6sL2PIGM0YK4Nm<_H~8^?Vzc}FVDKHQg25l}4&0N+0(bpm z!8MyW9>U8#!o7&h@7A3{4|1QH3O%!m6XIi07ihliVgLXD literal 0 HcmV?d00001 diff --git a/crates/wasmparser/benches/pulldown-cmark.wasm b/crates/wasmparser/benches/pulldown-cmark.wasm new file mode 100644 index 0000000000000000000000000000000000000000..e803c16352bc6cefa5d207bcdf7ae9da0e121c6c GIT binary patch literal 1983577 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�N9IL#McZ#5u-`yY_{1NB4I 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

)&pVAm zYQo32h~1i<=LC_nfIO}gT{i?F;1$dis^{oJuVJo0G%jUz1e&r&CcxfTPHzJl{}()w z)x-!k@3r6WSo`y+8|a97mG_wk zqnyQ7tE|P?c=2sF*hQIL;(qauZ?s?zTBE9)EV#+6*5ImShMQ<_hIg4)D352J!zr$n zNJQm$Jl=Zb2}YJUAgbII>m;whb~SAYjyn_=RS?X@6#pCmCRS!0{;{2vU(GgAQ3X;P z;EfI>i;;IQok)#4hIRr8p<`$V0OL@SJ18qSbcU)H_M7k+TEMbn!q{$99vQxv_p+B%+j zY9FkLAkfNf`WF2jDD9VF+e}*m7JVB*W2opw8HbC0(`)DTi=Jou$l=GxVWcK{nEPLP z&aV>;`rmiXFDkP~Zluh1Bd<=qtszjET}PlYo4>KI%zg;Tl=a40klBWtEjT7_

5? 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%0Dke(9UE=;CP@%Do7!Sz47vodlN9zuYeMO?0?iT zAooCe{HnNxe?qq`0x8=2V?#t6mRJm*TWx>i{Tw4xfW7r^5Md`1AtTWpiC%7G6(D;< z0W<+9+*4VthmhXiZto216o?Wy zqqNB?GrT^qs$)ss+wSPrLFm&6>|+qoD(@hr0>+J2!uE%|456;3$x{hY@!L9<+H8MYgT)v$QiNWz{rl+cC2AN)P53~Q2H|+KvsX8<)L$k z`2h2im1jhp?m)~Tc1bi4C?F2d$n*%}kH_%Z8&k_3UkdDIMB6!#A6uFursvFKjX-HZx~+!hE<4@X}b!K$QD~uiMluk)f30nb}b&+ zR6Y)_?N)eXQP*JS!oD4k2vwL~8l3ZHwn1G#z%@?%g2%wiQT={qVkZ8-$@nBt_vH*U z5)Z!LlgY;+{^bBTFJ+1V?AZXf86nf%4Bm>|6xLY1N?Q0I{Gu2WYUWrovhUna$?(Is z%D%6!w#lA!HKy_0~BJ^>v4lRn3s1^~STBO+JzGP-HPSq5< zM2K^l%N>%q2}ph=d#BzkOL5mTeWq*#Mw_1ajT|>UWs|d-w8rcvCp%f+2aG!1kmR*Y zzD|3h`N{&5(~>(g>oVt{vk!uy7>-KdTDEojLlhGLRN&e-w>PZYGyr9`@1-nw)UyDz zJ>1KC46g42#4DF&@((~F+7h6Q%6Cii_d^K^Zri5J83r|1aM^Djm)ZDpxplf2MP$x1 zGqQKO0s!}Ocpjggg19=5uO^`Fn^Mblc@Y+km2!C`REr#$^UX@xI33IE;Ys*(#?_|q zJObD>O>y`w0f0i~W%3n>M+F-8;G2UtZ!>%$>TCdu5Hf=SypBjkBY=GXbVB4%0^0*P z8j)KGYysfKTkw(_-owf451AwS!=y>Jc*6oBs2d z4Jg6A(7;Rs-h!a+yHnA|*6=};@mP!dS;_QjGOGa)>bv_fN*_Yv4Y-r$O#ovF?293$ zT;EQtcZiu6jXAvLojc|@)vSK*5!ZLJUiVC`?(b0DJQDYWwz0ZJ1p33NR>ND2k3PJ` z#&Hf)1}p0RXquCet50)8sOGYkWvpdqGac2^%+^O1Le)Y1 za&e&NKt+@SRWsX&P=Qub2)Y8TS+dfJ>9detDNr?lu&st@P%Wvqg&H)Rz+b9C6ZFcb zWh-~7L9<9y8nl4GM%SRltmXekgZNvxjIKfQ<2Y`MMC!4j8YDfsoK2h;_NY-0;4kgb z3YMtUsTTk>K-r@MNmM;Lioizi(Mhc3|F=CF+460uJrCn6yvo4B9ImS^j|^;N9arN& zxvgM*rc;=Yz%in=Z6vTrv+3MA7MD$}OCrmo$|FMQ1B+;45zpcx0L8UzCvsX?ry{6Q zOIXCe%sgRf1p!^9_$uT2dXa0LX56z;i>^{KboI$>>l|F#h-}XPO}*l#Rz}rjoUA zicyn;6sk`SLm3`imR9)_TYbK|Qxx^8rR_;}_=85#a zNF`A=fe6*r;>4{g_hz+3W<}LPM6MIJ*3q@{Psn`(M^~`DJx;9zF2*Y0S*`^Bom~m+ zLgBm|I&$fAAb;JFTgw2dW_mS%Y5{~&b#~Y-=)Zm}{S~t$>QGq#ybgpizw5gI7_L`2 zAzP*B&omO3sL6tWt~=sp>*iq{bmx!er>Ie#*-CxfHmhkJ^yiPXbR7(Gv`*l`?_al0 zFmeZK+zJM26J`7N57Z^BRu}X}8K^5*%X%8f4IHS^B-fs^-b!q0vV1hSH6*G@ZU_N=z-$y(W-M#b`*5SUGLu=$diLQ4PI6I~VeT?A zKWUC}B@w#efzOjWX%Ue-o&1sE5yx{TTWH{oUS&x|1@&5@BGjZsL~bpS?x?Aeh)_YI z_VgyV|J{K7?0IBWso)|2YMM~aA0{Xx^9znhsgs=d|4W1oV}-nQLM`{wqz)O1*#6=SKZ2b8*8v;Y|eK3`*md5ZLG=ds(Jnw2GcTX#p$dV6xadrj>n;6qXqD8|21Asu+hy*wqBlCW0~?vUtm5d64nfGv zWPMXG*cU*AAiIZk#8prL_)d{Xx|WpPtllE&;RM!W-9CxwRj1Ab5K0`9P;a@3B<`_V zMT`kT7#j%27O(`6-DAPn5&*&&_wH7ZLdLjn=i)}EoXvjVa`)`k*YZ}fM8$dyfRJ^u zL_K_fXweHSNV6}f}jl|vKSXHwz5xK57PqW#uXgCuQHcobD zr?Hm5)fz?KDh7kdb+w0ttLV(5R?F4s%-+zMS!@8v{u$^Njy7&pP;a7RM%lZ7?nG8l z_W#r|;{xVi4=rEJ^h#Bh1BkRd%d)iWADWsALezXTST-&~5g@x4faOX6k($?%qSSm8 z0ex$_nVL7-nsz8sT_cFd)rd%G)Z&Z?UEL?MTD5v_B!G!m3_=qDUCpDi)~tY$$Ed0! zLRH6g*b)}H(baqfYgtb<-@uiTI_~&mHFvMv4Lx)*xckluUM;L7@PGYkVGWs3T8=Bl zRhOajoVUWm6)6=*?7Mf@27?6svHS|8F{mxzqX|I7$C7}O z<)hi=)SCHNCzn*W9ik1UT^4n0q#o`wkk$(F0V~=L7#=Mr*{^6LF2I#dAv7QEfIBQwYF}s25daNHi;a&J>$#@NbB?y@* zSTer$xMOr^0&paN8xV<-jlnDPHz6>Yyw&+13_TerH({XgM^PEyj>ZN$(a0q2>|#<7 zGB#dEZ%<&eLH1MFKBQ$Bf%Gy{s7(hV#Hr<`(KIGs4|jVO)2s2Z06;W8qT}EJoQd-6 zRuRY2n`hcBn(L?k0XQa;Y4XG*Ekdq&R>IMg{hdT#CMnT=Cn1iUZX_bFKKju|7v@2d z=x16)*gs=ht zyG^{V^rfJ1a#sVj54qGQ*JcBC9fr^!u`SlL7pvXq19c#4(Fdy782#9Uh};*F#GL-w zmm1k6>Q_YPP>@^Lnc!DM-I}0>u$dwMCa)CPhyin_UZPsfI<`?=0d%@Lj+O;?*DWq*WG_c&%)O*fu`(2XY%ImR>3Xt);o)$M6YihU>p%2$uR=d%ii{Y&0 zZym0%D8FHROkl;^Xc{E~(Ji_lq<<>VKhv0=*8JH&Z_U?tw9I0iYP2i>p!$c4!^I@7 zpB0b#e9iV%rZIi0Cqh-rseU=D{X?}_hg#NZ#SPw2@VBbPdRXxaGN-I~4S>js4=0ed z;uDx~9j!Q4l(gYbS>e)hyJe1X2}0&VTQ)Wt`Q!DAv^^L(MAMg7f)IV>9!wL{gDiV6 z%K*@j%c@~zK*<{M_1%L>UxlKTT2=$d8gXH@mh|c29?Wn8ijN5ZB0i=Clq?@I4eMrX z!}nlht9=$Ly4cQ(CJ$M_=svd~M0E7I7cjlrYF|Q@xz3}%y&|9lzP5WclIgy-%#OMn z)l9Hb4@Z|8fJEdvICQQ5(ATbHwaVA7C7_FpPM2g?H4u?o!&-gq;VkrT9em)?@OiSs zA#g66aH*XqUdsgXqI)fyk*a$wg3!GdB67TzFhy3;*4GYCBNIyDX9376eDl+tU>xHG zieQWAZj52xvXHsPb}kJ)9MFu+wRVM!mIW;Qdb_~oq5on6XpF~eZI%|Cizb| zT>>xT2zzi_KjRp@QX=yst_Es)79Vjy$b1EWS33_v$b4)EJ8fl{Ok}6+dx()YQ)K1` z=CBvpyjL@aYuS<>$n?q#jRg>yp~(RyE3syyb}bT{$pVyi%mbiFY`ah#Vj33MW&YQp zIEaw7pxX756gMV!>Oka!Q?$fsB)?xswnO+&dfdC={I4Yn7 z25=IAzuy2(XSK=z&Lg0!_g`TE7qQU4-2l3KjK>)bt6pT6y1PMh-0J|W#6%i{PE-Pr ze&9P_HKb5mV2o*io$U0O*5FRk>r=x;=cnOF?38jOHWH4%CWI<+5kYB_-wm~P6+RD-5d z6#ycg>P0~5)F=YFPLcf_ogyNuQ!|-f=~NSd9GxOD(y3YNp;LxG7OkN;c3}Na+BMPs z0EBI1mSZ}g>&p~^(7gg8a=d~tMb_^B)#u-+(1;FQ+LOV>I0NMUUt~~f10rx2QkY|8 zp4K0ROvHc!u3iY-dPKJ8(*4(P?Q@dja zGkv3JRP9veJQoWF1+BPzr{E1BszDUsBLKAk>>urNm-hh;C-A&oF82XV004!Hz75d> zWkh!ZO(RjiD4s%I^JPPQ(WA3e;VA%30F-VmL;Nq%t!Ucg2Dq+Y>!=aU^((rimvcLG zY_(sOT1oyzgI)`55Z6KWOLhI5)3nam65pspTX zf%yOS)x+u8Xu+ShBGt?-I*@|QI1g1p?)-R><4n>J!S&hEx3>5`eAOOB(YLk;bIhqv ziHVU{_j}c%4*h;FYLhXBBwRlKNxA)WC_o$e$agCW7|@wyp|_ zlLW8G_4}aYb4q0`KLRKiR2Y5SfH16bG#A2eUpLDvzEm%;r7svcv~*ue;O4$mpFGJu zkhwL#ZXI(spLZkf`P-*IZfICZYe#@p!&^qP8apFXQXWm8gmY#! zB64OmB64OmB64OmBBEK1-_DtYN;73`Tz(OBI^wLr<<~$P0q}b{F5Q$S0{B*r%g-+@ z0l-?^7C7Qt0f05++$EgYh>&S;p_W2TgNwj} zOoPX-It|VbQ=_|O8vF(-$?^%8Wv9W-0TV6zESt5D4gd*@{~*1!jLoiTBmKT|m1g%v zN;X@*nVW8eBItezo2>gKgjexPc(RzY!V=}tS6DQ3!qVgF z^S4Cgd?ZQ``bVOO$WZ|za#Vl_r2ce-d^ce%~O)zNNv@VzL^tjuw*x0jR~~Sj2Th%%XKCL|{%Mk((e3{{J_= z%$dv6pI%T-rVM03*&>wPct}CMhTA^uLqT9cnd}uJc1Mb;YdhkJKiMBT0}BT-U`_P zc~pyc{lGCUMKHfgI9mfh0c9cH&xn&>ZVjuH*CW+OK}r zj05nWf3=T8xEBJjF5%+}KCZ^Yz6lROiExRE9etl==)zrE8#f;OBrDt{k#LU!Rw(mb zGj=bsO+i({cKhw)#!(39gv6Qf6rKlh1c>aE#PK15PP2W7-_pGR+WQJp&_LV$ylNwX z3By7Sp?JC@GnKd zmLQ^Je>E6$ZrqPxE=)d(z2PAsLr{kKglFWv`haB|4?u*w1c|16 zjt+S$*%1x@7PNs(_%sskvcNKiYlZe05I4?3Fdvg|y$uI>5Ys;HC8l93L&5HqknwzU zLxkAX_7cZ~4TZ4B7a*5FT}*2D3LkH+JA1ZT2Eqp>TbWe>$e#P$Hj!gXIG)y;UkfnW|b&G?N!!^|R> z<4k7x2XxzdnhzN#&mp!G3XGkN?{56!7|$ah9v@s5H~xbV+Z$Ki7gxuP3lW&;-tFSX zRv0<46H!}FXqUYi9;YB6sr|@*apML;%i*RysWfiPM_~MdR&ir7LTrp_pWYec4uSX+ zy2On~5STaFH*V~K5ZlGH55)iL5L%u|p2=z41ZM*gS}nB9_{3z~_!mN}cavuPZA5m( zXO>$v<(ct=5SdTlMo?1uapORQR=A@-ehDJW3G|7Z@!t{Ir2xQtjv4O&E{{ZL)f34c zM#MtPrJjZ0(?iP%7}g?`8;I=%#75`Ejmo8F{CNDAIKLM#za(z7MhTU8F$0`G4bfW9 z@*&cG8LLc7`q}Qn(T*uz>n2_ zgmrH+?L${O#v=%f|APO!{}jZ}#{ZXtxb+=+KB)UQ#P&qjlzn8zN8$fHjQ;jBkd>DFl8-m0u&W zjRjy9D7ztYDS_)nrMICJcgCY0A=xK^4&5|v3`0mxOQ16AyHEykAF&Y#1ubOw$S_y} zowDBHV>ur2ukqOQSH~#d%0(aj<`^B}kCxAXGW}8+H)^ZU^4n3vb%;EJkAauFo@ss1 z9(qxnLHB)v*kVM=3q1C}VQqsF0{QnxY$ifQSJOHPW!k6V@ijt4Pf?X0%29}25jX5| zJjNk(e#4AEi~kwa(|L$#TA!ojpq_6KV?CYsr36^fVc^*s&xdH*v52iiXgv`E*coEA zhu|?6q4hB2uy#b5LCQghu_c@AK>XJc{ujh9ZW%YKyWp5G9ae0&2rI7cY1-Yx#v%@T z^)@6jp`D~hIagxP1m$0kSf@?mM%RwQsdWx|(z*zb_~m%KiqPUcbp4}F-1rTl1-?}j zuXp3dQwRbKsEHf(2n2#Mm9@Yl zUWvyDgv^#G|CEk#;{gPGnA40e#@O>fey#|6wf9ghVFZBC1s)(T?2 z!y|+G+q?&s;?;-=bR_avr(vAMPsVV#38AVdnzj&;zMN9Zujv^R&XF z|6ejbTt@NZFet)D{At8GZyq*C5yjz)oym z8xPh%^=Ov3JU8tLqljRq9cN2;28$nsk5TBrKe2Xime|}YOk5KrUctm$N#eblCEisf z9vdW1KZe9dNa7LA5?`(o4@(Fey_k5<1lWilhQvR83kfXoP5I94IPk7qyZ4aqUqitD zkfb*iUds^X8=CaIB|UNL34u3!&wCcYWB~16!xt3&UfA&=@TKV${tC)G0=IjG&%i1ryss1p8v-`TTq2!NH%6 zPj1G0V;(<@VqJ_O5`$uGk6>3I+0IZbx=r>?pp1hlx*NfM4taKhZL31C4@0FHsQfoD zbT;SBSg*LTErLB699)3NA_6N=T55~9F&M#~jbsxMd4$0G0N%&o&ujzWJq!b@3H%4c z>p8?Gp#dowUL%k~@Yca9W{*K^C-@sZ#$){0T`{K%G*(8_8}KB8A-D{&TFA(~79(UY zO!N03xL5e5^$EC>G@?*Ec~lDZ_--)2DBeBTaaCu~VRjF7TH>Fq`1N(iu6x8~ndi1m z2u)wz+^%Sy5>n5}T0QxL;EWJS-F4o{4goYdC5E``#YxwG!oB1S)_) zd6xl*ly@b8PdH%4lo$Uo7RWpI zF_b`$L_?oLaC;{b3&XZu4!YYX;W-~;$W0@sBRwy1QAm{q%VC};D;O3hh#kFdhAeQ2 zk@f6oueB_2BZMq)`(RN+j4WYLN}`j7Xf-$KC0gi+f8=@5Fl3fiKk@f*hQ}q_EOIsm zQs;85i2#;rg=QPUI3!y8F>=9Ys)j@q$z57MufCh zEzcApyF4QXn_p^q=IxKx3}mekhqpU`Q2<(f

?e045RGJl?~b17JFVab}5k6@W$n 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ξBbIR_+29Kr{G-j7VtLkj^n%{{HuT)fyKc6z*2z8 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�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

f48eZ~>Ksr&9 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

m)z5p+^k@Uz>N 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 literal 0 HcmV?d00001 diff --git a/crates/wasmparser/benches/spidermonkey.wasm b/crates/wasmparser/benches/spidermonkey.wasm new file mode 100644 index 0000000000000000000000000000000000000000..66bb153bd8c1eb6f6ee698fb5f0537a90d784a09 GIT binary patch literal 5399306 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

^@M;Z$`gqXvNUefTWok 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

v2sQG!mIKi$H{B1HK-o9 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

iDnGr52k<#ClaibTQo{!^`R1%T-l;6 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

    ?l#evBykp+O5%{@^E~yW^KO6 zQkw0Jb$XqyjK2gZ@oSQh7Gw8J#Mr&hNO&pyEEaKcJpLL@lr@*ohxp;xlyC=g(0ZRU znD7B_lwI->F;DZs@g;ht`wgCjYqB1YVOHvFGH}m=r#U-FJ0!(njl4w=Nl);YH|Ft` zi{lf|!tY_H2923^=ucO^(RW@j{-2mLi=pWkzu86$SL*?{0?RU1OaL)I6A-ylp zg6bRSN;&;lyf3EOIt+^O>&pcdW|%-h97Al!;S3VHbaI5!PS7mq9*oWT@;$AR5z_ZMJ`uar61D?uU)i+*~Z)l`z_=?p`1Np~$x9c{_(;QPMh>VXAfpzJT zq~Ypys7bT$$%jYU!H~|MCU6~X;Uxr zc<64jHNjC7*kID9cE27q>&k>JY2(8B5w7(f8M6P9j z(bjx)iZY&hOQZKA$yd3Wo1!2rk#D8~=uS1O?3o~OwL))2cdDk}^EP1GSs^?+RM#+G zddFnsEwDqC?|GF1qu6^CwRTK>P1+R?Vctm1VL%(AGmiI@lNG)~vcPKU=DVXCZup&z z#3R%4HKZCdetSj@QD)ad(K%j2&xWit%uw)+Jpd@kkuAz`NLQvL9`SB|@_~_?(*YP4 z&$j}E6_7`NbV?}VhL~zWYk>j`BSsLErD13Qt`A+CKkN8ok4`>gQz?^`+M!Y%R3V0W ziP`W03W6TYk!(}GDRCprG>K4K#FFPrXIi#1#b>R&A11LlOKHh-!aYDN5>o$CuK!RPr9 zrqImDb&W3vD(7iOS?7--k0*2WClhVl%gHjeKfmLrxW=`Xl^%8)!Ur4!rb^VzVk z0andtD}Ql?LVQ~OC8e-I2`2PMheiP=dBb+812x`KP9J=o8RnIPONGr0;Rqg{Bi{8y z4Ytx7FTX1keiDO3rO!Mn*@=x**ZZa6TD=4bx$Pk;CSG%tIe zzWV>S=_qY^RQFt3+kFY5kwfmTVYveKtEUrlCfOl-LT@w{>EiI!g#Ch=CgZvo0-a|D z;&`&$m|_X(p^m@#ln*UNnyif!9>LRsv(l55yaJi)VWh;IJ$(o4EVsysvT;%fc^-S) z;9hP+W99#d@HkN{PD5SJA=ehFp;tW)S-~Myfm$@7n&=%@Tn(NQm@Zn;CYP9M9ic^f z=E55G$|6l01bET%@O^N!X&TpJ3}0PFb8~eaaPQb)y2lgq)de<)+X_^XF5L|@?F$R~ z(Lmd`ku~})qGh0yK5?iB%4qz`B5`z0<;ua417$H#0s&5e{~UsAlsxNdD)t*r#1d6c;R$>JH=S-eXA|#5)k4Wb~c>0@+ zI^&H}=^($s;Gojn?8 zH{z*BY&bC%-J(rkv3?V3+G*hNc|qp$gKM{%b@nPzLP!s_FJTyqoEO_X>-*B%u=%gx zBLFu3wW=6qheoeFn+WE`ww9S2C5a6kmqoMWZ$3rPOPlepIywDI;WJO@jp=XP#}6M- z&D0>oBN_>xmoh-d0fA4N_^AKofUJa$Q^T(p@oMGPaV14oBX$%1SrrPwF)wL0Go9LAjT)76;e`1 z<14GHo>d)@ayV=rMsarvTosQVJ~@5Z<0uT36np}jhZ{z@B}YmHeVt71gTeSWH>wRJ zT#*;FbDdbc2%~@>K$H$dm*F3#=i$qNJ(@VoZ`l0QXMXq3|M!=MUXFd<;Dg}BMrqw= zi)*$tc(c!D^uLLihx3(}H$V0pfA!{DUkXZ$IF^7va$DbeI`*@Ht5#19MXEu?@nNj) z5oJs_HTRz`em>tgH6Nd0YHK=hY6G1JE`V}C@QN1s=3_%^bNHSg8zYm%UiZ1HHsRs3{>-G2D;cae8Lt(7k6D=CK@)Re`?^K!_)woX8D=b2q z9<47-5PO(tVcT?cy*1yw2S{w{a5k!od7%~nz#74b7+d1e!`T5Zy4Nm1F>FCG?1SQf zxGNYK{}b75M>R^F3grW0B9o>HNQb{qw*tePANa#pq6@#_C!v_6$E-2i*j29dC1E)(k(K%=jv-Ij zI1hR>dvSia3+EZMObubZR`6U{uYkChdNrK5ne{AXrRc7mDj{tRHHj zA1~HN+cZobd~SLP)(>M@7Oux4?RWq(`G3-&(?YgCek=1#i1VxsdKh+yPG& zSQTt_{MS{rW~K_~8nP@bBHq*_%=nGm%Qai^zI$=er&e)c&DTWnD{OhIS8tl**fBTb z6};+R*$u61KD|f$%sYL}&vY)&A~~Bvqkex(jGZ7yBM7pRCML^5)j7@C=p4@G6v8v~ zFV4onie_neco>EEzM7ZDIAU=(@(MWB&^wgb+>#eplkH8?gvkV1e)jz$ocEg}i%a}A zHyvGX%_m}M6SK4pE$+(sV6bUC_whyNgu$j+T1^BvcPY(Ln;e<~t%fBuTO=mrL~h5& zy!eXR{J6M?rNsE%Wx=Vw04vs=*(b50b?+;;L`~#XRLi^yrpP-RGG5B9IOVx@$q}j{ zL)0N)`P*9hCVNKh*|16KELx*nK^(C)Lr0zsD)G3rYjogr%`P7pnM9p9FRGhe9NKrL zv{d%0qh-T3@$?n=r(m5hU*N?8fMVS5smOU+q5q*5{k8NFIBdmS>2P|#QX&T9zbrWo zk5|Je!J%bD$ft2{FIjS`gfR5Uaw5{2pEc2YS=RvDI4_fUR&O69YHLdnMP>Esp z#ApTYr0;5R)UpVYYi36I3Bo)QSc{KjmDp=${gtIl@3USzk5s4Ch!ob z^3EuWv?h#e7_v7{Fa-2NdQdbna7wl!N>~_%rk$glAgA-kpH+Sf?R?mX11v|)b5CZ1 zy1M0}$NRg!+@w^yP+Q8XIX=>xMf%$%MO6kj$#YM#5d>r)RF; zFYW<)+?!b|b!rpcm8$?H` zm(1<@-#@!nOcY9k2q3nrn~w~F|E!(1p_D8w-DF~o>xzJr#I_3Z8MLLvVJ|M-tk_5) zofX!MqtrN-HGrT6wGhjqCy6tIqhc&}sOpm53mXT*f+JniPllk6FtY_dYb*e&U}Wvj zWOt*G43)}{{}E?ySl!8*#_Cp42(0c=YjvY}V;L3rWk7J8yvgdux=B{I9}rCush8EQ zPvbFfR%Kz<0aCNt*e3YyT1|mHi7S zZ2uCt97z=%$$KHKpADb3a0_&wP?aP(N-Kl%uR7Yn4oz0A(Z;T8DeM%*6gWj}CfH>ZQ3_cyfh39${XZsZ5FVVH8gO?eYEa{u5=0}3 z5{h~+B^di*aO2mm6$g~4Wqu=EXT7(ahCa07fGk3j*~N|=+gM;j5?S;ve;I3ot|9xp zM?ndTlpfoyh)n`r>ab`v*e$>flC-ptqe;o$z%xH>o`$3m9t2sIL6*o58|EguvJs8SW3T3o^NGlj!9k9jnTqU*QvAdeScwADXv^Mct9G>H3uv?~rb#g%FioVme7yaI zcN}M$NKp|Sjg)1On4g@gcMU81l40jue;kRx7hp#$Q?Qp8d}K0vGom*vlmi# zwL!5wgLVXp`dMkXq~MU8G1SJ_xE$|l+b6t+x1(X{N2n3j2t{xNH67smf#)H(3607gk=VH=+;0CC?S zXyCG&A^3a}9rmCcN)IbI22cxz!s}qVv|_93D1E9cLDO7*&H!_V zdPlaoWOqv2MfNK~zz2L=0mR6%J(7}at>&N_%EH0<@vLf%59xIJZ%gKbL|j$rr*BfpO!1)0zOQi0QL5T2YKg0LS(X15Q5|L77*65leUM z%4@L?qQin(oFZB+Pb;RLX?n zq23|DgYl=UV&k@^G<9+^0RIg|nR2N?lZ=x%1WTGb~Rpi@n7uyAu|-ZR=l`iZ+xFTs}OxDw^q0SfLz2s~=<;o7Mr zhc)9lx;)%{PW`rk&aSk=fA$R~+D!7=b zHavO;=$tA@WZTrm>3-vat8`?IUPJN(2+ia^goLhbz%DG%01!%(FesDtCyxd*WtFwx zUIGSCrt>~nd5MtmpUHD%GLYI2M?g1_0Vk-0ZcruNpc2_vSvRmSsv7AACY=S{0EQ4_ zo)1q&c6H2CDRbxw^fc_N3-HyoR)sHEMO1j8O1k5!piV?5s|y-qR54Uj=%C@?4XA5K z2x+c4q68_P;Y~qZ?jqXN%ZakIsFLubQ;Gz!^ek!IH`F6W&_bQyfShTPSum^Akn|G% zCrNsnB&j?MxOk-++lz#VjAeWqTNCL-(9w zh3iIgARkmEy;P-+W@&^xWGbNvCzR0^n8J?i0o{`;XM@tC-I0l0@O=D=V7R_Jy?=fB z-*pxZE=){8z$K)j0rPa69yfZFQbva?Jswq!Q;?v&lmmu$>a_fR&Bwp{&K+%Av^a`i zshOSOjgYJyD=g0qkstTSM!n8f0}b1AU*WzoeDGf0Xuqt)AG(xisaeAcQ^4`Y=_@7h zfCVsa-4DI*pO^HH@p+8Gq4@})(6ySIeok7^T(SU)llL3JAg_bdA-w7<%_=y@{QNFE zEkLw6tk9yRiBz8$Rq~=T!tJ?*Bo1h1K}Yne{H7bHw`;gMxWd=Ctu9iYvD-J2hZCa` z+Sqd{)TTdqfHZO_%Sv)R1TaFd#V2tx;CHh3M)@IrOOhly1I2KNNT^FFrfGOISs|B^ zlW5>x zTVTSj-b6-THit{n`tyA|^Jw4nejbh->nCxnPT%qYrlUUPQx6Qu=#gf*GJTcRIaYWu zeWlK)6Z4WYya89GPb+qe$Y6+|K#Tvq@1H9=?U!ta;ZZ3J0~t?3B`lNh433cCq#Bou z1_^5;uHu`^l!tCQh#UmeQ+%Y{a>jxLK&zor@fXlh1~D|$*J|i!sH8#!cYx@W!zBA) z`dz+>QW{w}ppf*I%EF$0Xd7L-66(fGohG*KLUsfGkZo%qU35%lN^7yLUFYU z9{z(B35dg`B7s2CqC6P?$B0V;S&Q*HPTPTaLWYPLtWIAoBs8B_b;(DamiZL?0w~R( zdG{Z`y1(V@d#j!#HT#{f!X9^Sjog8(7KKAAgtQ|hC^=G#TvW7m?O2lZ?koxv8a*xb z$NG&o&X|Kd!TJr__l+(Z+v+!jFmCif7xbHO-a&;Is^7rrt>0kp?5E$TZYMo0({F_0 z3z`jJYB_uF`%`w{KPo%$w-)U{2g2mq1TQfFW$PfE>?2P4cFIzWt(lGNK&zGub|Cgx z9p?0IJFrN0m5GSjMX*KdvuAowJk<&MUqBzUJ!{$`P&P;la)p zYfgEmym_@=KPL3SaGZXRn7?%1;OX4DO82jpzGNM&Dew&04SluE<*Vgc+^8{j3PxhC zANJ%bp;y;B#g3E>iqgnYP6Cu&WnWibrx{*BYq|%}3|&nQIOy3+{p?j-X9Ko!8eAFX zs`P?VFc_MiKg>r!QLnkZXe%{KDl4!@Z=At%y*zxy18eyV%~L+c5dQ<*XRM9wl@8>wKEk{mZxxDpnFq> zy}=uh0G|h;zc*ktBAgE=(m~`pOh0(W=Y#1x%va;u$Q7RUYD1>9WsYBIMms2 z#SVR23EBWap%r<9QFLi6`FZ0c3a<7Z;1Sx_Ls%gn(J06vV93d}XlO7>DlEBIO+W;I z4`-r(e}_xN3T ziWeCeOS3qB#^Z-T*BF01CT7$2j(JS)%=880Z;0)3iG9bcSpK}#fF6Vk%!x_J@D)Y6s019HVvIS4uPIH@3eyh0P1RIe7#A?qoSxW|;3R=n=mqu;s<)}G3IH|W`3QT#V^h*+yU^@AT1yKs%R0 zo4KK#40C!+E(Kt84B%)lmH-}w0`yHzDDBJYLQ~9syZn}~E5C&<;46TL#6ev<@pa{i z==}teCA;)+L4~KWUSlnKDVRT&Z1GBlAiQ553RIE!AHABfuqup#g~^*pfxbz-+h9-G~@VVKy8oY>`p z6FdD%&B(}eKu@f&b7JEXr*S#4laWV~UC)UfvjxF{5aAD-dZ7BE2k%2gsxw4_T2f5B z@=~6h&sBocrSqA=kkwEs03PvR))Zi*yb_Hg1o66s_-?fUbJA)98S3jC<|@7oqi0d^ z#fK*FebNM!+~-J@a!HV8@_9=Eh!tKr|ZFHbDa1-YnqeZlc zlSAmS=8anORiFuVoIs)q!HVuxv4T>bJ6@GX?Wi}!(pK3gi;5q?EXtsaaw%n0+1X~w zAZXsF3?*g;WvBpea53?LMappG$dqBBWy+HsBy5 zCL>6>N6m6YF>htVnlSFfRD9jjeA_`5ONs-t#ndwQBQcm%6#f6}VeN3AKo^f#yt+c}aan(?;X)b)r5lB-=e z3_k9jfLiSf7gAJ_ATdk^=gQ7T}pQc7hZG)M!hth)={c<_+2qGTSl=oT?|VYC1}I8E2$U#K8oG1SOJ11{{q4q67lS~D*^x`_jPkRK`+A)vls z0Uc%)GgAaC1k9i(U`T82t6r%qeMFos?EuICPgzqe$N0T{ue_jX%aSjWl?-ljk{P0_ zVw5^Hg3H6!%(cZAR;iCIjIh>YF>i+yw*b#k8Wzl3aGe#r0HYQULvNtTY)+OSw3|?& zMIPX>%c`ZPm@Fe{%~jcO*0UayxhmI@Yz^ZBM-!WGE{sLK)NU*u_#QKr0nrW!q2?ky zEBn*d@A!{L<-yy^TwkackClXAu;vZP(*ZN&8tIiRBtD;2ZMWV?j9!W{u#xmc4MRQl zSlQYr4oLcKV!CtAM3sOC_YT&4zllRIY$YE+eTXIwrVDf;)p~xA;UDC@N*rMEq;G_l z?Y#LZji^0=!p(-NjqitbI7p)&O4?Mb{1)8P(8!I6mufz$iUn5W?HwnrW@yP=9%eq+2t63F;b>+}I+@Du6_kW=3N`X>JtH>G} zTxoF|kb~q|r59BxNtPvZI<|ici|Nq30>zj+tKNDjXhQ08-2qaHBh$8kSmkuQ!4?$3 zu3M2~(dg8g-S;s}pcw;$Sz&=Fk8EDzg|JSCa$ut>hGEwly-5=oh!*J)7@FW<9g`aK zq#m`|&+rq?CS^Y}0fxbV8}^xA%A2GV;09I$3=YAHP_2%q3v+eI*sucJMkwm3K_H+E zWBC*;ojo4!w45rHXz#GfInZ?OgGL@n7u~P`otYIw@TxOH4*YwQBphjA!1H7*-T2>^ zRl!bg?f6yH$ko3X=M;8ZsQOsBnDSYdtt7qec4d5O{dib^5F2gUbK%uOY#Jd+dnPQJ z)1I}{4Zi}&PulY!r#&-FG=d-02!-N|MaSCdTk2pU?b(nGnJJ(vlHd>JooT#_qix6f zj2J4eN?e_^sm$W0ypi!u;5fz~O#1&7y8TzDWWJwqqNcCMO!7R$=vd`EY+yMU-&2*v zt>d&6SoOn{DLXF~heAE#P(XHe0&p?2NQIA%o_Fldd(0-vE$8UkbRLkBCrozgJ<5$( zOO@14AfrHx-v(Z*WPWmxci!+=f_J$S=kUN~*tk8uqsJjp2C5)4nC?(rG584J z=t5m8NtVmX504~z1-4Rx7FLQJSl%{KucAID^NRO){-}<S6Q?luLujGxd$=?%NeV_7VWIyt z$KaZQ1NtuhWolloV;P1Rav6B0i=$}2ntGcpCUq--U9XOx zimaOq%uSxiMC$ifWUi;kdRI!5MXp$Js3++wTFf~M66+Q++R24n+>KDM0-+<7f#S?X z6Z%AaLMS5kfQQNg91U1bnZS0u%{86~Ba{#$wlXC-4vQBC3S~MuUd_R?R$$VsUQ2Sk zl!=ZUFGG&oXCOIF1J>3t9Wv8%y2{zkzNlWUrNaTu!TG$dlJd`lsFnP{;gj! zGCt|!Psw;!qWF@K@gFLN1?ISP+U9|WzGnxjlY7Jh{K|ne<>$ez_`l>aw+2m(4At-W zg_$BfV7EQPgX{+{F1iDGI>6QyU&y~szE6Ag%l~;0JG9(rN*m`pho`#1_Ho)aFKjRH zK0Xsf|1EWO%lOD(`qsD6Ni9Xw>~H$L-_P%5H@@FD?jLqW8M`4@k`$!x2_hV(2Pcpr z;~boAg>rErX;WU!cie9Wz+Q0AQUO!Ult`tM_4H z5cq(><&+Wvfvg3|3B;t`Hw`OghzF#AX(X^kDj23IiDTv|m1#;2XKPCG49DvjOW5W# z%kQ=oDm?Y)W9G~B+W9P*3?n(>csP^c`81ie#mUeIx1`Q4EVb4N0A)a-{e0)?>0Mf4 zbT_m=f(E=J@XAJ}iLRXm5b0TVEG<6U10ZkKdf}*NkL$8kn-2A{?p)f30t2S%R(_{xRpFKJst6#SkI7%Q+qMnQr&qof_SzrzRRd-$MS(4tJfC(3$_ zz&j<2F({JOaGODQN)aRQACY|RV?p;mXkBWUyuFw*8k+3$PoTl|_GNURq`QMHyQW)Oyh?%pxN8B#SlOnSM^5 zCN4{>Jw5)JasjTxU2sLUv9G&@D;E~vnvy13xTf9J@p}=jj)!Hq(m$N84_C1Wz;PAV zp$C*L4KTrVl;FD3!F4%sN}Cv^5R)NjgE6`eNqJ$Ea94K(3GF8-7huHAe5ZqvXw3w~ z@~f$KoeaF!SLF}}-zlQ|fG+}gLQB9$8((Y)8uV9#(s(Vt7A|J4b2a8Hb2T%&nkVom z5iLx6wkecNsnm0!Vve2TOE>qN@?tz9xO@)7E+2#|rU`=NdRJhO) z#;UI*DTHXLf=vRv3N+RPNrY|AlB>g40;w*Q##j8i&4Y1O{@;hU!26*o&!?eh^AXb^;CXQRK?!MZf(N)b!cXGlooidF{6{uNxIT>^ z(tGjy>5?*Q+`;)IXx&+az={De zp@1lN?%)od_(76&am-DF%+(f zzK->wAPFO6WDHmH!Tjsq{I_HN0WhgidWJ`js@=t@Q>eBnNK;yz`t~=JF9b}7908%_ zBzE~^Fo0J4O<=4K5xD3{u7fo}ZnA>^w#YgFnYg?FfT-ecuqcOtA1_uD`f{EAT%T^S z;M?Vy^g~#)4QA-)bhDh0#Ux%Vw7*4_n?UGa)KWIk6uy1TY}278=)!v9anu z88m_6osfOFFe9STNf3jT{qcf((x64(N=KR~NQBD=7!S2Wu>Y*ra$ESkbb3yq^&3+? zVYXHE(uarRFI&*Bp_4aSi3WyiR9XCfEQaw02%QeRz0|mk9S^u*(~OIM7r{4o27~d# zPnB(u*ZE7RY=iUY`7&MIQ$B+Cw9|orfRk~0RXEVUb2W$>TZm|Z_n7qRLEu5o zQ3BP2*jt4IJtx(J=rtZyILKh@2FmJ?f|>fj>#LQM{|!qZSr`mc!a8N)3ud`SL=k{c z6$%yU5^(tc8UWHmb68g!wo()&Z--{u3t=m)E!bQNTP47`P=Yg+4wQqEwga+XdN6d% z5r8sjk%Dl=+6g}zvRvwcfrL9={IV~xxOYt#8Q?T5)WmeHJEF5>R^TcPZ3US&Lp{3zPfZ_gV2o1i{i zSOebBDXr9^z0*6@D4f**9s!8xFI%eQToE@iN7{%eA0MP&^CVeUq@thIddNy9a}{-7 zGeMG*83X&+@VuI%?0VuGg_8NflTE7%r6IU?eyY37I4Z(z?7bmDn?C zR8w8c@L`wWs&lsqTq&fgtzPnFF%VeGI%V+&C?s!w69_1`7$pF`36FVtFwC`?IMm{w zDy6LLiML367)(hF&^7Jmx?rUCO#i)BjEVa_IwS++>zEx4FGM|aH^41=U=S>Y_OYef zI2?6KX--uyPsuu)ZK{oR?I=o`FlCtBr4(sPXjT2sM?L7&wr>zv1?wRIg)tkw5RXRRr01=eU4_@gXGmifrZ>3zC+3Ew*^ z&=yIaITp{HZ4VQnz&8u7y^t$ED50C^v!50dm}G2XM!3XSL1u^9_b2R% z_-3ZZR}3eUj;H|63!1`&e)RoXF!-*qjHA1H520QgapyzqNkKxboTU~FP3w~4X^Nin z@dCi6ho^xeXYGrNp#(*yAuymwgv6Xsvu~%Un_Ga2-mcsVDdl!s$cW=CJo%Q{(8X|N z(<@7d>xVrZUj^{L?Nxzi;Ot16I6iK*XZ;*#=y4T%VI8E_3l`l(S#o?7G0`edR9~QU zPmhl@J);eCwGp`{kF^L`*x0ed+rIl^@>`y+3E&0}5m3qg$^Sd?)^ z>a)u~_anRa5*Wn$8j52`!dF=^#p2KuCyGN0DfEUn<7 z_(7n+@mrS;3=|?)9v7yTheA)G1>`JPxStYE)Cf5GA9U`KB*S3(Tkqg&E6EU}PB#ik z8i_B9lC*bQlWp$%B}9$Zs2k~c!pacdcO&E5vab9o7x_=enNwUHPfk+TlP`_-%57n;Pw{lZfJ} zpqc62>e7*4#4rtoDqmTDEt{_v(ov>|5Vuuibl2ISI?n4_r@-Z6`c}cb)93{U#?z`Q z5MX_>!7rF6m=jf4hnVU3jp;ms`(IO%7nZ9D%(o-lqw9^&U95T8k%(+56f)-eFOKu(FW@mNo3GJ4r8W_Ud{+54qr#-GlcKQa|I;6vbujXA3g8sudYY0LQC?q zb7wS;UPa96k~?2TZH9~PS`t(=7YQD9+fXC*mo(#&y=$2!!@j4hyDLgP>Nz5*Bn+vY z4k1X?*n`)D@rGkOS{dCLH+em%kWTa7V~`v2K?S3hT1u3FAqEp9fkL8PAV>*mjT$6R zL8G9S3KE`x)e!@rY4CfsUKw=g5K<_(8yYEhG;N)vgmf zoc&-qXiO5N@T@44^WiSIT&Uz#%7`4dnV1zT9=m%ti)B-^UopKXUix?{JQ~l>?~c5= zn)M-o55JLa%drXrMT1k2P)EYT9B-OyS0THKtB`+`%+C_`8i(p`W?EhxkNWhaL7LPz zkjAse`qo_l#Fj-8jv<|@Pw_H@UX6&f0jBAvcf;DT!-`XY|^6)K4UO z(@)%B%=Fj+WGX5?od`(%slhwi2Y(5?&#Ft^pigL4g8-9pqJ#><^`L-7?QRfx$f$E) zz|h(O6Q@cF6L=B^32UtL07+OlNvz_G5i&2bMPZd}NE z@lR%vd$%T6b)Wl1pJqfauU7Mw;=^gKF|1jQx5u&;Z$EWQi#HAaqfMztJEc}X)Ry8~ z%Z#Lg_qbz&eenS|q?fE~1jXeIO?Z$peTS&S6@cZ@Qbu0S0Ou6U+Zm82%D@Ool#wBi z>zTWrk@r}h&99y1h8Q7hdSD=vqV$JJ)s!J(JqhGvX0^e*y<~ssyKqo69SWT(|e}6HnXWXv${=;j)k#rC9Jr2MjFYt!;n}f2I^V26283 zhzQZ(N+*C5loKq|!YN-yOOu8(CZkidOfj7VWUK2n>0DYJ9}aXVBkTe$`G~V@XT?{w za5(8ZJj;v_vbcmkGmBUjq=RM?%|1n|_adE3V5V^2CgDl5m614XB zTkH_X@-|wee&*kCP|ieq@%Ys^Ci8ub4+UnI6-UuxfK1GnI%zU(aU|o5VAgQ)@N%z; z_KSDOfZw1^fR7DVioaH7aMY5v7Kl3KxddvhagC42Agh>0QTwBr**sOU6wOiS8`ZR{ zcu2|}-$>ZFZ>oWhP_m2rHJj?Kg-`ri6y#mVl#*7dZ+GwZQE{E7rnnPNn7q6Zh970K z;c~7DYZItDg;O=f)U$ki7L`aTqIgTn%%O_OzEj zMFV@Qj(Q77OZ*@z6$>oWVcV7L{YksCgBY+%nVK&Zb|k8pB47h4Y_Z;r|0PAF;(z59 zqJLg3XySj>f+VH)@#G~!Y;F8+PMwB1@pXh1g1`Ey&s>iPxlSw|1FnXFsfAx+{jlC) z8`cXb^h!NwK=Gu5oAWu`09Rp7E5*mPSN1HfYfd(PDC+@H!&Ae3#QjmU=_h{S24MQ4 zh;W?m3u>%5MJ9$j<^udyVhSWvEwKsAG_4fTcyh%Q zaZXZD#XI5#Bl(~=B+E)`!qFhnh{-Yv?N)rWzj7eRl`i}9t&%6Em4xW2e^O?BzT zyIh$uFjZXGZ|h_+cdJ_rn6Ob{dq^VT64B1VFn_Y*_kH37_dG!y z0^);7ASOcpsBg!QKQ;P3{b+ak2YqPZX2@Jh$PAf7!$i7F5GEpXFK6~`7`L<~XN1@2X>5&wr zdg}h+yKbnbt_Damk|^0*&ntdhl4(4CcJtw*?L;km#Tz68#^W0#c_4Ibtl<4Y23lVb zX9^}Us6KaZ(+Ye}BMA4lQ2~*X6N%!Y(J0=pe(&8X{y%GeLWxh$lvq97DS;GGHJ`-RTdA>ZPP`jid3)cU{-P6s5=w zz=mDrCe*L~Y?GR)=*xT?y@Z@GNbyY9thlxf$A6ZAReDvk7Q^0ebY(RfjBm=i=yF8N z!$DP2#kg!dF%^M6CvscV4y=*Ms z#HF7k)qF&%ncBpAulxdW$?-PU8j|02lNxN?uC@OTI3+>jNAW^zi5yLDh-};$+M7vw zDYm9b^T|+EwKFqocV@Eu)7_bwt2Z#6N|;N{SF`}r*{yJ_v zpxIDO@}#rz4H>S8&zV3>6J|C`P)r1#^-`p6o%-HhyNO;TH8{gS zNlNDs1Bv)%>B0EZio30)I*bg~&tjaD#90V4M8o8FhmFS-qLy0KzJ3P9FY0qX5u>T6 zTqM+5scygP1}5?QHNt2U*1@J8{aB7yBRZvSRQEqi!x=tsTA8vk&9Y3}Se@Nu{&}2( z=Y=U2T5yV!FO5S1wdnHr6C4VOMv)GC)PX13-0tm)>?2O6LCzG=tjXj2J9qXX(R=+b zqx-s*jq|-hJ{XYS5@}i-yOaL0%Mldh#b2Zwkee5ujvFpL6NNb(YKm_;qBDv;7xaKL zS=gp_q(8p3oykY~OfBzm0YNOo#BLW!{7kmdA+I=K3LQd!1z>3G@Ok>(l^-2eH^^mM zJpMrdqZy5*9C^ik;?jabadP||bR{^f4nhcgOjM04;Z;+~*Idc?sM5)-C3*MAtaMa7 zoLFBDu;4a&%QY^V{x$G>`XM|-cYtqKe)l^LK_6dv15kN*&9VC6TEw+i!yp9|l@Gdv zeu}TE5=GZj7G=gSlkJ|V;sk@Hfo^tT zO4n*XHz*^A&|w|zkd?jXW%py#R^Rbbxm1>UAa=fT0Z(yHj<3wMeXE2V&&J(8$>qb( zZ$xp-Jbg{i5f-964-3TrC9 zq*Ua}c~%>HOF>7B7yt7|AiMF8_xsw>(G`FBPOTehsK6Dd2^WBnXC#Jo!0Yf3Fxxch zS#iU4eB{z;d?dw1_xC?|GxUuE8S?g}H{W{*VN*4v45f@Mv_7ST^jl3fi0;DG{CYyo zdjF2sP4Pi&#!|zp+RbM3YK}a0j-YOeb&)4Rc1%KWT);V4?;2M6*mbpjFPvH3IEDwNnvov2nnfq z!&cZsPp+4SHM6a-AH%`-@S*CkGLcgr*7K;s#OVK{-Y&?*;&qG>(@}#)Q%fR^aOTi` zhAQ8e*a{1y_VwkFcP>R04eAs?k+{p@dsSuy5ltW5(C(nxB%zz`__G5^Vsr zqIm1ifLMA6DAW=W{&djlV*?(7Ms8m>qb8)8@Qv0J)C3?3F*|F-NJY9^_3~Y(THUmf z?YXj0NktN|FdW;p5tSP%OC#DR0wB$!!T960^E{h!8AWQ#gT)t<0T~^5AkLr)Namr8 z9uwG4kB91T@mG?>CPrtY(72)n$$LqIOhZPf^}hm+=c#asn@`h|mIupfgbZ9gn7>Fs zbP+2nd4C@`=$+m30v#ezPCBzrO2DTS)usY2UVJ23N`vv^r^^x!AWmi9s?$v}I8 z)z-Pd3E7y<1wKEM3tSEjgc4(4Crj%o7dR}3nQ0pZ>!qy*)sU&u$p9|g3Ei494a129 zWtkyLXSgS^9eqD4HqfFPgi;5P%p^ zkn7&Pj8PHo=b9dxR?K9iYVnBXi8AQIFU+AmK-EuEz3HZh`e6uRDe)Pn`%ZdS z)dmxZ@NF9of^G~ikPC$Vd=2=@Gl9?7?*4vEQiK+Y;_el zDaaQf@l%B-Wyl<>ueOFexMWE{TuPgm6)G+CZHqgFF7Is0KexF`M~EEtWP*F2-^0t4 z@I4aJ&hC>Ts6p}f3$0+k)DJ$>Gzbifh(>St-4*e>?7cm^zlZ&v=p9fVI;0l-{2hO` zt`uJ|VbN8@?bqzu(-;xcTn@KuXYoMGg^3h~) zGwI$7pU7f{9(WO00{$T$2TovXx{HXPZ4dc7ajt9vUR%-vr^PPP!a{vU@6v^FY|C?2mPw_!ywDfW zel$5KQIHEVi2TGL|ymOFvw0Blbz%xZPs z=^K*G7}z5?ii5iKN-81Cim~eQ6Tbp^i}?y-IuyPemf=wrp)M(*jJW7Qo(L1Qm*t_% z4E|NWBvL?(F5lN3Z6ikrQwk>M^)^nN*IP!9hzNzH`20@-Lo97R8M5yumwg?XM(GtqG}6L}&foXH9y=oW^kJ@kzy z=@0tD`G)B*3E`F+v614Itq^dJepHA?^_y5na>7p-$x*{P+L2t~tCNo;TTPzCNYX}P z9-Ot%9ZA7q<}ot!;CSUO^OzdRg*1}d4hV3~NOpR4l961~qwYvjHC%$G%{&&?A4&K4 zbVrh$86HV$R-7Ywf)S~xstirc`|nA|F?*V6V6jGuuW3W>`na^5%!C$Et0Tdo5RU4RM{rk)5h(zgKRZKNuAeVS zgBF$frw|jPMH#5o>cF07I)MtuA7`zE^U09uRlV=_?lhR1g7BQhg+faCLt>@v6D$>F zeGtz>j7a_Fzhwo)^vjWJVkgz|hCY-B%hW+&G%Kf+av^hx;Bf03t3T{#N z^NrOfz2{+L^*oF*9w2CUNRijYE3E@@ae2A;eR`yAUYA=$tjo=U#!(iu@mf*F8 zzjsA(OrBLIM%pYc=$F0v<)8Z{U0&X7lW}>o`cagdaRxz~Y_2BHK!EbfsQe6JB@;;A zh_eGLk1u-kb_ibBQ0w?Kg~v+iL&KJL&epTPbZ6pAOkMPyvcJ3qv}uDbxCUW9n!C#N zN)B#}$Sn#r+Y-SjMoM`GBfY~wCJeaR9W{;uRKNx#Ap~1Ep+P+@bWB+bKQZls)-LrO zG)T>WJNXw8^{Gp33jmr#MQl@v)XPc^orZlYA8%^2I5UL9KK4yOY4>+{q1x}UBfCdS4NH5%@bxSMN7e#elLTic}I_BRjU|$ppB{OL1 zNjBZBYo+>IH*HD`q|7!Ao0!JQ->PXI>T#MQn)G7#OIMklWt!}-hI8;_KUvs4gH$@g ztPHY^0g%W|gDNIDRL}rmW;NY+(z*y!26v`(!qhCd<;EuuEf5rD(&!g-&1vK}LOvJM z!Daatbrhi-hJEoQMWRB$Y-xQ7D!P75$%t||dmNW~LeU}tPKVbOEgSR(uDGP%6&PbJ zUFLylRBkY@-PDJ%>CCG+vu2%eHQ8v%vMEWHIZKvJ`|F(hb4jwybtQ|x@K7i@GWFwu zMvxVM^pRDqecPAH>&we6A#b*{@&+l^9Y)5SG8tPt0GJ`~%ACG(x%fS*U-Q15fPFFJ zVY%T74GdXF zG#HwuVX^l0MMLM~Zdba~tmP$B(BoCP5)8k2Jp5XHtpj=O`0LLJU z@Ea7H+A)5g#Mmx+Y^e*HS49mgWQ3#p4Rh%XQ)odZb0r{Z07zpT?4?t_JFH!i(hlo1 zJ8VQm3@Lyxp4t3-JDwZ!{vc}VLM%vT;59RB=<-Dy7N)@M$c+HEDW15YA}qU82T8Mz z+*p4)G<79D+^uU$Zmi#Q7qLdv3FHPm!7Z7)z3sC%t`ZC=x`uTQI&VJvSIrxV1Xz>= zCSJXJ-*%G}|7MeXCe1r|FNH=FDx1mC6V1Jv0%?xO<}zO&UB%hDe95wo<`-rr8cDhI z5>$Krn4vFFsTX3Ie$I>z$;oJ_%@f$=C&ezk91NsJcCZ0w`(i6dZ~NEkq@SSV=r z0&n`EPtdCO0r8H$y;5b^AGwp&mQ}nmUU{GC_nVelKfH3@<*9H^m&q@RA95AGQEFAe znb~43JAs2=@<0Ys@@iE&uk&Ikousi0lJw>Pv43B*hf}ND)b}cW_%J1M6HX0etXA-z z4JqpVr2h{!+6uvq?UwJecT;2IuuMOd*;Co0C@+Ej4Xe(^4?YITA}v@LJP%t}B8i6N zueDU0Db>#UP&lZ$nV)G^)fw`i7fQ+0Q`7wO)>S?L2>wlFuPJ_B{%AXto}TKdMKlRU zcK3+C@7cI)5Jba9LA~TU#cq70vQSk^!6p?N6$;uND~xBOe&Oeq%uF97e$$e;KQInH zy;fh8XzGBOKh02n_9;O5*;7IphWgWo%g;RpC_i^fD8rfY^g;QBrvT*_P6=iCG>`a~ zo&uC#Iwh1Tc`cK*`f{)MX%y}r^Zma#kFOMXeDB z@zCO+PM1KjBo35!keZZM5eB%+%)QR5m}}EvV*kDITeNHiBZuKDMx(E(2gB(DQOWc* zpZI~5jsJVz>-BQ};V)NH|Ezh?c^jW}9?V>-MzLrtBp`SRvX_2^t=~tWj^B1N@X+q7 zuRCnL@GqSh#Frsik)rtZGRaS&Qa|FZMki7;xe)anNA`C84vOQFmWtz;e*8c5c>GSq zinObVd5l+HZ;;Z~Cb3rtP3}b zW{$F8ZUBIbAVLOQ1&MTE!IOH^hHCG7INsT#=0YN0PE=B?8yyfq=lcY^y$iwtSEaNv z@Q7Ti{^HlPJ1jQ2$pd0k$nOX$_>MS}>D?b+{fp}<|6^LcV&$ldA=P}2)(}+lIV;uc zZ&k^(?+lu4)+64V5}H5)bWG9N(jmRZybSWvW>$6urd7#iUCoXmDK2kSIGd};1Qkz(CD69K+gEnLG|3j9Dj+o53|y@-rzSCOns#6TSapt=?Zi$*JF zDe&0)6Fc^h;t)|Q+8;7! GBDPV-v{Hc<#3@nEU!iptGS^Ax!yOs1WOg$#N@QMR zYDgz!O-kVu4$APlCd;A&>TzdS1;+Jd{f9bnOY@*qfJ#J_&1osjf&t-cxi z<^zjnBuugci&Xw4byFC++_Ijdg z$mC+0zFk4p^#bk=$0JH&NxH$&)l**$ibE=RmL5?`2nSiZ0mvG0q*k;|+85i`+MNw{ zi0_^HmU-cV`Y7h6ViG6?FI?6qs!)=OM_`|vLb)#ein|xA6dx3tU1zo1dQs?h{o?4I zyfC(kpME=+{`{yv=ga$jp_!Xi62GsJXr#| z0=l9q_`gr(BuTpikRqTX&<;jE`Zk{FI}Sq>sTHsH3@YWbKBlx>XeolYSN#sfiu>P6 zarT`E$|j#zRvpV%c81R(A738Z6A1R$!B-`epvJ}a;;TC1N;ORHU#gRixU}e9aP<@z zU&@m}^B>g8Ben8q>-gDRDFB(+Xq_Xf)@bI=&v<=z*Z9b=KSyl9IsxG(T9_T#zcj9x z_34C{thh^YBXAW-ZG~o)T*2UX38W<=^aQhFpNS$C=iO;S8k*P~qYhiW1`(sr6`{?_ zhQhLk{!ad7g=JG8QQZPLP887T3e>Bj=Q!K}V*k$k(0N)e7Nb}G_Js?DUZUFA0pd0Z zZ9=FT8Y!G)9o3Jf8g@BXOY&{$|Ces}>ax}Xw6ezRq|YJ02r>OGU?A+NT=H_~mwtlY zYtx%f83AgTDDo)gSiVo#^-dhBMTZy{M**oeCFGA8&8=KJQ9d1K|itTC{6Cep6?QLz@{+Bw@0MjZgIytM@=U ztiK6$)FR;^5~Sqd74_hTe3FMUrA@P#eaj&^L@R82q7PS4sCFJ2Gu>$)S!yJw8bwfSeKd& zRm`jyBILVfTlJaG-?-Xr>U?}YAHr^uq<@H@m3|t~tl|Xb;=S@!!)st;<}CZTf+{W% zDJn6k7%nm=SPLxTqL}7pEk0SKuiQfstRPWn8rCrv`cS+EHen{AohN(Uj2Md;4$Yjy z^dAVJkSz^fuAL<8pJjURt@^@dn3()MO|;Q6y%up^BFl{M42qz~v-hLP`=wI#c4Nm% zLr2IvwJ|*EuBnq9qcD15BGf0D{3_E{E@5;kH08I(L~%6zfg_nMn=hs6c2TI_#AwdyQe5y;J*{ z2QB4ji!waQQTi?A3{OQlGX+FBgPL*zPE!u3#Sj8g-!Xc@m8Yr7cl-42BK64!yrdaE z82{gqSfNR5Dea-o_lFB#QZA*y)HV%ar`Ke>gz4>}#4bKi#XS@Z;^O+cN{Qno`y(5r z^c|Fn>ft(rCJv%um+`ReEwA|wXs!Q4vDLiZ%fO(sOGk**>kfkRAm(+pX|JMq-zUkD zMJGE%WwcpupyOk8E^VVjb^nsL(Vq@UybaIaIjAGz1`Qa&c2#bSlDSA4GRO; z0TWTEA(8&iw%0;-0{XG42xd_v9+c1y+RwK7m!z$7bCOT=RM2A$lW%EvnI;&Y9cRaB#$17IoU zBGUiGXyXUq?WbHm1JfNZt{42c zJJ!7#fa#8nWp@XBb-P2i$=*kX2X#lwCLUOmBV^2XS*@9DM`l=Z7; zBm3aYFu_vnmZX^<+Uw<=;OM}Df60BsQw*z31T|&n(@EyfrYGkyw3C@1I4Ai z&SD90J0aqn0^ksIit-sX=}suf;G9x?v*Nl)btS>u8~xxQbHqcboVY7?!pusRHZVspla;;tgaeN8FXME0YgYhvL*Fn)zUxKGjaKRhMRT=U76;5E$nUl4%=0W)sZY#6jq^EiC#CGD z)~m$AdaC9!o?wL4irxL~ViuWD>voQ{PnkT$kBKam4!V=l`lFdj*R?*7MePssTOIQ& zD}SU8sp~x6Bp%n3$6Qe943zznk5==hBz{HpMAUwJ^VIa7l*n5lO;vJG)8`gSdnp0! zj+BAD;zQwF1&&-67&&+G`FYQmbss#K7)rIOl{?mNQ#xbX$!`r@eGG?C8f)>_4~Gt3E(;z3Rx6GOd)@)r0MqpK6Og z?BXAvD*ka5KSqM>cgTCCfdO52CbC@RSIBuR0PG*o^Mk_%ySKKNw_{rbWhm2h@db${ z)popn&g)~UfOPP6Q64>@N3?lVzhqhk>$l2(q>n#vUX2T(zbGhxPjY_Vt6!YxV9Sy?xkkO=!oO%PyfjqEe4FA6CbkQq|GsY4?L8 z`ryF%HL}#w>iH!z3ayI(pXcX?xzp3T`K|7`i9Un*c$VL$XJF@6-CxJh6p*N%9XX$# zk!iRk!vhzzeZ8P=t$K`xMdJD=W$r(&PXj5BG+(Vzqier8ctMAR z4!0oP4M+o9ZyKljE}#n^FqEe7``gQ3K63pkIcP5^e)l6_LeABDlmu#7v#!2D=s!Om zm%Z_T=i|Sev-(msUw>@+YmnW3EuWz)&5=(PknO@~;`j?O^CnaT0;em#2--}7;JbK( zb65H!M%^EU)1{Me4jNeh1q6$FtMW8?-b!)6m1+51X@zh0onCSC#WZPl<+lx&#mE?~ z+lI6o4$E4Fi}@N58YreXO}GV3Zp2(qK_elfnDkDem2|^hIWr!Wk*e){Gd+mQf82r3 zu=utzF_!7dU^vs2!EM&7>wS zFedp-d0xrWDW6L9;Oj!u1W8A|7-YHYt+AXD;OHDq0nG8rqM&O14GTxi8hoktSS?WB zq<_S$m`+P=(@MTXF?sknp8p)(7Qanr&=DzAQH%VnDgo!`x{d2whSKe-wX{m1kD|Gb zo`CnKtBww8brb>>_R^WH4!}zu&#=SueJauE-#dl3 zGP9m)0sS9q(~{2V)F5os!J2NdF?403;1o(P)!fyO2bPZ*NLel*@axZb-%@$UBZ-W@yBb$y(0@l`Lfkl@;uT&>7f71M{;{{m5@A8(1;!N48sYVsIk{>H;rtaM| zQ_t7x_Vy-gpFXms`@v&dIv*TwZ#o}*il?1k9Xn(FDNlCdGiHTn;Q4`K_Bn7rw24ux z$>{^ljS+WvQ#7$g5|i@gvyMNDikCbNK^Zl!(%Ek_*;C(=+X3yPFB0N?^hLsEa6T>i z*LV`UZ?4;m^srm45c^b_+oZ6I zqf>+AzUoMe z4HnSB^Q>g3Q95_{js^wBZ8fye z-P|wgj6`0Ume=Yr64bR?CYN08SsVXG)@~~S!&$tbj=YPTy$Llbek7S-eenra;$$1_ z;sSAW*hhhsI^1dT{6n zFVSI`ttFduthy)T|Kxc@b{YZh23d}_>caRiNUA>cC$PwZl>L^`9`#T(1zjy?@z#`- z)h+TRfWaZhznQOxFE{96PoyEIVqV-QNu=S*t7jFT7wwtJq6GDY1f2q+G4+62-Rmkr zu!8`4(8Gcn^uX~#b2k^`PBQZ^)>yW_$k~le~NKv?4g`@Je#T?dW zr*3gn1}nGNON){)AJn~2jq_#u}n@8#fcttuz2!R8xFaNMRC~4v{!Z(`MZGU+8;i^v*>YLsq8H zJkyby<9Fq493m?(!!&a#uec_x1?GTO>8x^+P>gQj%3(2BhYqt$ywxS7ugZrln_}YB zKZHK2BLw-zkCOroQ+0#7sC2&gZz?D2JZ<=Ko0C;Fp-%RS>+u3;%Bshx!%8KSYB>DJ z&5q)usPb$SAC_JZlfYP^g#O5?VmcZZEJ8pL3aA}8u9^;SW;4}l4~DF=^e;IVhj?Xo zit~W&@h?oDuhfqhz(TEu6_+ah$p1E1cjfnGX`z6|mr-rK>6%b273ZvJ(TP&1C`y&H ziDQvK(HFo?ESY&zzK`N_%=lQUpWEGgftE!yma>KTLtp<&p@;G?Yd1OGN$M0^(;ewo{|RfjU3FgtatzbOO20;fK6@MtEHVC++}*oOi)3Q?;49|~I&dGeLcQJ$ zd4o49ZyDx4l+PKBpm&-&T5N)z3xA$dzv?U9jrIx-Tj;v*w79~sHvkRv&jnAWUe z>-eMgdN zrJJVoKt*+UB$=tjwg@m$x@kzDk&SQ729e&a33F;CJ(OhMCkBvMV(Nqi<8d0U9zkyc zTz7)^?!+gbL#o zJ)~z$pY~iVN#^lSWw7Gl4blq_C*6{1Llm8M2{%tSlgE9P8Fg}~*M*rVG`d{_Y|(gP zXtk$)ycv{;z3|8R<}V)K+8^{&{;c)L5^k`K(X2_*qbUn^FHZk@ELq)8G^wta*?I8V zePwo0Fa7gMi^z0){DnWnZN9I$Ewi^3U)K7}~&Cn_S^XHLg6x8-b zaNpi9o9~Xl@IQdpYtb>IOIy8@IEsJJ)_Eo3dD1R>9z{rky?TcIz&s#Ze9_SrnlS6ghWi1U) zv?vjqToIIYF$xXPCRUX^Nh4=(RceF*?SDI~AjMl`IA}O{eNmWl$fe@VZ|AYX8LSF$ z1+t9~k(U5ToCGA0G0w&C1oS`-zvs z6&E|~IJDGrRqw6G&~5QHb-+Sf30JEOYG8QPs!Th%g7t4qXFWzI;s?gy$MkS8nI|^` z|A_q7q@TCviWU*W3Yk_{2;Wvnq--^w@}QhY_jh$Ct7$>8&wv)+Oza_E;udc(^$RVE zVY|bY-F!9pK1FLQ{4S+eEr;3)RR61?8EhQD?grv-LbrR36H4)45Vp8T^B9k;v|pBH z)8nwCxI00YRhzdk5$1u;xL&zW&SeX0WgY{-46gr`3XMu+j910Q8}fXg$41e}Dj7LS zGQ$6!cuu64j$HMuD%taxRl_!6bw;-8GP|PMMBeMz%~98efJAX8s)qKc>V>4emStyp zs7fAovS)KZN>6F8ok4KUrk!*I zu({C{D~#Hp35!~pjBsyCTLo6GCJTsE)>>;^>9^FgW>_7C%B=2zCN`>RV(SKg+ZzkB z8J|)6T3JF__?K-QA9IQFZ-q4@%cJU})o=nJ!}jeL$w&!C1TBa#7uy3j7sz-SQQI2Q zMSV=nHWa$(nC)CzY&zp~q*ee@l&Ea*S)yw?5Az`N>D10aaj6z{(sne<2#}(d<*YBf zsPCt}(6D~__#EaYpayNXpn*=e(ERIeMUZ)(`lL!Z1cC9<+@wqLRSQ-&R7j&9F=0W* zdK0Ri<2I;}*V4m{I9?Rj-wOY7I7Gu%F;f0{H^4XPZh-fXTCUex+ub<~p@^R-J29e# zspN?bN59&Mb|(bfFR+t>BK3bz5w@g^ehg%#Q`GcP03%h&zD^$2dVZStrdHUpw8FN2 z`S{#+Jl?XF@UfpegrBv9AA2x#G-*rw^Ih7fGa~wV(Y~zkh40%ShP)2#yYCjVqf-gl zMY^3`yeyWLU%aesPW_9QH{|<_24mDrfC((&jxb&jo0!Z?f|HvPp41(Ma;{~goV01FWRu!)C06C`uycoYmXcGTGh7SP3!)3{ zaJft2M5xQh=eTLaevt?DA?piiu;P$)^X_233ueD|m?ZWqoQO*;m=Zx3YiS7jpS|S` zQWERMvKSkrfYB(u%E!&D+of2rt3foSPEp|eOqZt1$BuV*sVD)i?$Z2Jm%MHmU7Al_ zVp$`)ghtKsVZiFnv0G~$)kWyn?kq+mL=PvB=j)Uscv!k2oS$FJn_=T1T2IqiTftL% z@`OB3#yYc*GcryxBSaUq7pf)eU@W5loypdY4TC(D=wLN0|Tvd8+_=gD%)&3v)$cCBf7MBMM z{wtmOcxc7zm6Ok5|LM)(gj`yfXHZ1<__|M}^E@4blwvKH74ww*Zu0BDFo(=Ev$p%!ZT5r_|U+ln)xpb0NM2*DzP7wx> zy^cS8o#58)0#?jOThWl#OuIPYnnpG7K>l4cmq`^JH0%&n^bKWS=RY*dtVhW$Hy3>` ze(r5x%oxxJY9!}$h;`(9o72gLvF7J2-F9Tx>9|#rMPL4YTzeyRn-X}x027HG?2Vs& zLP+Ipku-6+w4!o;g7f2?$-E*&xH^2k9o`hQ!OLU1srpm-Q)SJ5*Q0@+a*kdJ{=*xSHI`36u&776-z`h zq$2*_CsRbNphN6QjZ7AsP3iO0F^8Wj8Ud2$x{U>}%=9y>IdmR1FlO$8$}%0$pyreg zd>bEw$CA-RTU&Bvnpj*h!H^JhsrDWGvfG(2Sxe!SuF$)lo_`rG+F=i8mH6vM@z;&B z{8exYV`M`I20~#1TVz>RSM&ptS!NUVH@PdLgqKb9s0FngZtTk`0uFZf&Rs6}5X1$# z_h5kU6^~!uXu6;xkf2S$roWP!?o;c4ch?MruloM&6J8%-l%0#Z(E6~+Jq?8Rd|s*o zQeXF^M%?!8=*d)idurtbwaexdq5_&b)sEMuJu(bo@mtqHJ!q*SYS4Kki$yvv_bzYZ z8S?-ahW6Tw%1uRVvtmgKalDCI@#~K2OoNN2B0fA6&Y7t2Qq_9di}^lBvZaKdTTHB% z=+&hw)wkiSh*_oksq!iL-^NaPXa4&(XFoInTxx&Zr3wDK?Q$?+RCae(1Gm8Y0O-j= zcT~QVCkfusNC4M`FOUUHd*I68v<7Vc^x@jt!NN*){wcx2B}aRKWn=C9HCQXf2^hq2 z@j!@7mTFHQAaSy~fztu#%ue}J0`yxAKx*XFqxOtW|Vv>E}xI=cguoLieT-^XF>`|MZ)GPN%jN_IaI>z_)ikFg-o`4{5&a)CLAm z**clOr#oM+nO;FtN2Ykvk%lKdiIMr&owiN~Hp%KKid_%3fbP^YOT<}Mwo>gnC1NI> z@*b95YY;;Tu^p zs?LrCqLWQZ#50O;GUT(kvv|Q`yj~7*&|!LL9Qo3}mILR@@1HVCG%lTT)T1Ybl}WjC zxLFF-24(1(=l9O_K-w3C#uyzt39k*}JV}9=i6iKS$?w-q?d4fHo3olAJ3_bNDNpMOF zYR@IUHZ2m(TN|#Ki7ab0(mHjp?Pu;M(hV`9@!-h4Hv4!wo4ifJL+VFG^mg)i%-iGf z;h&iD4#RHV{e>xZb93MRrN$BP&F5cw=O+LdUyipsuj^mJJ!sAe(9+9E&+V zpBN1Mt|Zo*qkj%40cd6Mw71aiw|e@ib6}rxG5!?v&cI04YHPka2#f$*{9c4T4_j|o z_y$ioQ{I>73JFY+SKp9%0@b%ZSORc73*_t}YHP{|d+d>zBcv`!4p@6l8%pKVpzY(t zTTqMQQi}K5cV%iVm*t$$6o7u0Ch44LPRK2LM?MHiT>ITV{x_2cRWnJ8Ps)iw~r zMPKAh%p&2)Jk!P`O_zmH%`Y`dS$*0>H^-*9Z)y6x<)cr5K7aY2>9gj%|48)dRW(n^ zf8zA{#=}p6KL6W4)8{`jeR`?)>7vgc4^6mP%Ke5&cv%1GueAQk$AU^vtO=j?N~_g4 zmIbU0uxyLiE#8;3U{nAF2phCkBcA(5(1`Ep=Xsl@^<j)@hB@=s)dDV{m2xN8i+>0m385)s|)9$3roAU zo>_m0eu9?WQ9$NS&y@V;pFsbOjens;vm9D$%3ATOm19lD+LR2WoG4Ub%>*K_<5$1w zCeWWxWg9)&1Y)*(`6-s$TQwM!^=VMQ8!AVUNmQ=o_C)2Z0w*dr*Rl5P$VP2uv{~9! zrTIvibVm_H2z(6Q<%)iO)G<_Y#b|ImPY6a(@W$d@I^%w^yFPtbtG{`5R9h^xKq?B* zWFZ_4qth{-7+DHmDd#V?Y00#EK&A1$z%|K;k@jlJ>eno@VXzGskV2?fiD##ZQXei< zX^k8ph*s>vpco|Oncb!!NtSpQ@E8ZU+h+;_Eb$493J$gz^Mk3aM-l##;z1KjAp+qP z#)xR2xsPM2Zh39PvS~0&=(UfX7e5ikBPH^stwBy$m`xYYj4*SiEpiE!SkjII7*tC# z%STV$EdRw{eT(OQqlaHpfKzL74gUCgtH zS}R+mNp^(*1#de|kipSJkf2d6D>DDeW%ZnCmsP2`v=f47o{5_4>NV!6f$$vE4ZzTv z29g*>ekK;iM>$#7Hb5!r9u$GDNuC3DE~m%P_Rb!PY`c32JBR3(7<< zOw5|4N^zi(9@GJE>eZKNnol?Rs()7skQXb?WJqS!2!pBlnJqtP(k@fC*x7__Zq(om zn45sR({w+7E6m>C_`1yA5B+1$-Vgrs?A5Z&x5(^;jf99k_1x7oR_fZX@63HsuE<&V z3nwmxmX&vP8}uvS$fbD2NkZ&d^-eT)S#qR9@jeBajw1rwZqV_+iiqu0*;KGLm6e2W zXZx=j-^K~*3S5P+$-Hr1lB`xFaBU|=BHnXKl5~y}zTbMn_sA4Zx^ffQz3!J!^ASI- zJHir!E2pUb&5FAvdbL9sW}Sa$KJaJw&|_4!0T%|nC`C6}g4?uq!?qp#AtB1L!8 zd^xymyEfYkh^YKnk{ZYAi0^u{Uk5U_%(js2?N+_@A6hk8uG^~7a@~ypdt0hon#LNi zkM6%ditbN=>g#|#*VfHWqtfdW49AX8ZSvxX=?7#h-WYZKs(Yo)+?unmIO!u;JK4^N z{to4yz0mA8w`L_>N?R7BB%s!lSJx?PGwNfHBNj$MooGZ``O)g3Rfs+_P=@p)ef?Od zQXTaWT}uL<;$dwDupt1!ZA*ne@50(Sj?y9V=?bxjsDhn_Hu3e4#w4(ZjIC)l#fVe8 zV&Ql99{b`gt0J;Ey@91i+TgoT{OJP$TMwWeN;dOHr(^JGvxG1lGYzyoUhqHXn(?Qz zcB!#w(#xoqv~Q|!^`-QLFZFRJa{aWH7PS%>D$3Bv6=02Wo9sUnnL)H1UZ++`W1Fi& z+PjO2W^SRZN|{O{9BX(pYug9DBast8XjQ5o zNQyyf?4ZY*6-q75QVU$j>^Aj7T)Pzw=HMLPXx4uz2 zx1LcN2O9tsL^s0dU00BZU61Y(M}uR485yypv;^K{zpk&W%6{!wrp@S}3pRr@$1awx zBae~j$GElhHb}&I?RT37v=p8B%{+k7Y$<~JG;Yta1k?8c@wm4gazIY z-H|@f#Drw==_o(Et~>_Zeag9ayo+5!RmK5LnrTgxG_fRN5PaqNv{L;^8xlGFL3>7e z_X9_j{fR>&D{``xnX7R)>{ff+ydOi>{?MJ-)O1E$MRHbMN$UFDm}s*-^YKY7ZU^HB zVi(H^BRDi`<17`n1SRx}%>=@VcL-hVwG{EgF!+0Squ_CXC_FcDFzuR$n~!`qds& zRfh^!%!6W88^OYG#6ej6j!1GDo~`L*l!!G>dYbejHnCEXw%auH&v~yX2r~<~_y4PG zTP>;%Zf%F$O+#&i&>q82tshx_zKF%;~Pbj174 z)u#Asgp%J|VK47?%e>=n?d zzAo;P%HbhCX7Ehvj3ViHqD;U<$-7k&XXN~T2z2A1pJ!^$)l+ZPKfgyS0Qs8zsvgWY zuSkX0edP_JKlJ|FwxoVDD>%VG|+Ci$asHiTut|%(suj4)!*lysb z+HpLudsw|nanH@V`(NX=&VKgpS2;)&$(MG*0?Zjuk`r*$-Bi{lCl{%fBD2V33xJke z!n?QS!a`Gfi~6(>YT=N#1Sd(W1yKuqVik}xFs`|>6 z#W4n|&$_>A;&qw70rPyWaWb8zyPYfM*6n|MDnyc3?Z!Nbl3Jc3;mRrhn4L>->u(^hp z!4cpXuhpFn)PUnJ;Cy>cOfJ_I8=Y0x7GaLMwgODLuIo}I)TK%H8Z*tyl%9!N+22+? zXj!o(dZMnwXan>*mEWLFO8BzLR?&z-KeOEG=AHrI>AG%CHFQ89CeVj7pu75n2Ii2_ zFr+qL*L6*S-k?)m1=|v2k1`*iK3a{xvN4z@nY}tcD+BC>H)nHf|CVJjh#@{v(E38 z{9wB6-~eGBiqsg?f}b-b#umzFNY`E{pUE`k$LF;zAUP*z+LjTVFkAPu+POl{7LcXp z0_gL>6XNeQXD|j{kr+aI1M_Te)@6&$>#>k8n*pfK(6}#@XNfvQGv73$-Xg%VLlM_G zOiHWd%CT@_)_-X|L0R*PHAb@qJ{&Ng7LvuK18eCkVrc|bz>_6JnSW`a3d$>BoLwci>2DQ$mL^eZjo=X|n?Ev-28LPO) zETgl^Sha-_Km}Z|o+{~Cn;FSzMO7y_LW^40DIcGkKbBfqqTr0`2HEjhKxFqhOmU7F9lUA{C4)2)8$r*8~B~X-S?CzcOBGX}74yy50 z<-*<>XsZ_A$m6j7ir>~D0z9)gDEWcy?-JQ>10rcFS|{74A*?;^9eu_lv?B%z7n?^% zV;~mm;1$a-4>F~|kNTQjtOYVr#iF?3Kv1C)+wHYv=%nC>+7B>Gi3|6DW~r2>PXeUh z74KGugJ18xG8pqp^$OUfH(N1-EB-GxBU`o`Fb6>Mk|vp_a7#cS`d@#vURVy9(<1nw zvFJlE7s=5mjl3ksLELqepItes4~D3!;de?xir~y{NJb`>I+Z(!bIf?}G)Z8Fp?$gL zf+G&-D9020sx~obxS47e4E(;*>MPR@BUK2N#mfm`d`N;))JQ`iBUDX~UWCTO!hOc# z|K2MrjJBaC0tFFdWPn}Jfj10+tdKM8L{RrY1lns1=ov}Ak3_NNZku@RBH~LKmlB?$ zVhT()i6c0TG#{4ZnpbS9p_bBJ{lJQ>s?bR=0n0OrkHwI}qZD|pClBe#1aSmlFlXA- zC!*-dmNg(DL6q`x7H7D zs~^(T9H)<|tXlHMsF!=9;vU$QU#;(^94R<0tdAXlRp`}0lf8`zJ7TD)&SQx3Zm$L2 zh&q2^>$T9Cyr5r%!mc>GMbQ6iuLVuW^&%d+(0DGYgPT{v!&M@v_uEG_V+q58zR92b z{TclwmgD-hC+k?R^<;6(gEZ;Tpm8sv+=LG#PebH86Lwy_S4EwaogtssI6f~+W2n<; z^{~H>IHgQUPKLb0DMNK88iz%R4X};BxI+?29xx_{Jbeg_VLG@{GDQs9%vNqI#0>Is zKD~xO@CAz3A<$FSOy8o{C!b+0uyL+YD6wC^l+3cwez{bZp=W~xQLtcUZ0hGPsh>>a zC;s#e2u_>z9Lr#f16^qtVwEo1ha>R@G~^m_RliYp4LJgLKS9s-tlP6aGipn%hJ?X( zN!_vDbjS9v0kP>9T&M0Acx`1%E2;x;J~GP8aE)Tr7-?}+}7idFtut>j|^*>>Z(pyrxwJ# z$A(H3Z0mZtI$}PPMvci|d{FuQrR1XV6pWhqpuNilBPUB=1BgU0HOj|vDG!(m#RPsM ze+Omul^j3Bxw_I=;i1JR#5tFPUUZaVYTX2}N30*{Ue2~fmiPGb4||rH!z-?a9Okzx zMcHJjWTdWPwrxXRx}LuBuZyoVFVkmC^zgs;lKhqnHcNZOSis# zQrrcrEG{e$+~wHRr#kScJx|Q68#W=o2|5Qe2{DJ6qLJttErZHtgY;r#Gnj z{GouD+G$85nhZ`wgS*-$)VzFq4FCg)Yi!&>wS$9Lf81OX4C$*_LFQ^lZ2qK-LLSf| zE>Vwhcuvx<2$sl+k&V6nBr_7B86=|M`bt{z+a8=X-4$y9v#38dfX1kw+l zoTQ&RQ0k9NKt>BuEknwR2H86G2EmIo30(s|%yq4epew^@yfU3s5uTi#0HMD@LPR6jwq&C(osa!WJsiIFux-0aSHB^Rdpl*5z6-5S` zWC?Xx-6o2$W4d|h(ZzU?Teef7wSrjhh@!E8I;;*5r(k=77PWx7$O0tQvu z)J`dxy;?LyxYy38*8Gs8H<=&y(oyL`siRA5nz9lj(_>tl9*%S2cp?0eO;bK!&KLuS z%(xezOiW0BF759Y);;Ge(17t)LwZQ5nKd!P5AK9F-tcf}B!EHDA(uPoT@7+`BaRA% zZjg@>KClF9^bO`DH)Y(&xxGYJ{04_NM6$#TSCqttyUGn7t2$8Hd!6u&yG%s1tY1cM z^d+%~$v7(Fi|MM^h9M_aRE7FBSxN=bkfus1K1c3(y+{7nu6xEo{(AaVodf66WL_vY zC|+^R=j2%}%agz{iD6OhY7~D~6Go-xsJ4An2S-u`Cn&J|c*A4S_i~81E&};onBNfuzDI5*HprCz7{Z+s^eER{?TO#F8T5|13c%WcGt}z4PSeHh3Y+imnYJ-vxZ`> zDPk$*gD5o@SdQSHP|O99nz*X&nZokWH20c`h?{he0e60HFLRisygl?>iz`$mnYf@8 z6`JK@7nI}%&Z%dQeoH-T+$(ScdV|AG?v?gNo{r|ty6%Kd#3;1E=1f2#QPiu05ElmxpNh*j+ZWg{cB;x=oYiDVfoa@?LxSsA+3a*pn~+dOzv}ngRP$fJPCA(3(tiP2gikD zaySrdI8Bq~Ot2-Ys(GjudV`1JMKeR28sVnHGX!gKNoBBp@zLgNSEghW<1_wx`fqNT zC&ze_cgORo=s9|s$DmCH2>jZm5b^*^0f$r)*G@f}9xy6%CfcEN2I@%P^1ZUH_)(tf zAm@I@KkG(nKyEvwsmzhMohnTh$}Ju1JJ7%`NQ3J8nwS)ca2aJnmb~!@wChnUO*u+M zwd~?pnRbcHOA;Z>s7zl^032XZwQD=QUMH)4OQ8;_co^{0VK&vF+IM)+7xsTE3W@nc zt*BqpTc}(W)L}MiFk#0Ss@KhkBbkY+Vcm?F8Y+SE2U3# z^r^Hup0Df-9XfV3KYj-`P3CfKw9k3-X*M3k-`S4}O%m>YR??H=VWGe%ht#E- z3j0-#G^fA1o`_j@j{%uTj{7yr`71cJ2N`06jHA004PovcM3rG)PYBtON#6R;@OGx4 z2o6N@DyK{*%GFMonF0bVtAip0jme%z_uB_03&!DfNE{CQ6&dUeV&udCaH&uaU?>*2SVSQ8rCF1)Fx#YS+89 z?tnq2pV1=cs4)FUYK4bjSrkOs;*X8|-2MBS6X~l7c5Rlq7xK7is7qvVv{#eGaC|7A z3Xab^!^=$MhzA6H;&A;+CIe0Lf}zwO2Zr|>2eNN5l0?OPcyqGz`%{Nxcs|D=8GWzz z*5?z^C1?US5tuGuJwOVvg3(hqNB2&@IiV~aGvXGPP!Ke>ISeGaKmK*?vz4b`h~C|E zsFGmA_;Z5%{KBj`bnl7Y^<{2tT~qDa>thRy3+oS51xJG*s*}Pnn+Qi(6HI1e?+;0 zcN*FT)@KK(2=jptErf4hUFDoSR{0=ELCkFW&o+yt?Od&$9Z*5jle!;1O-jQRV3UuM zgC=$AU1A*UPDy-&LR(kDKu7RU5!eMKR5TDak-*;mEgMf1lVLjcOt_Oiu3aH+}l`1dD%FM;OBCCH_dYAa*Cd-xjz|3@!OeH~>Nf zc(aC7$UMJChEP>3*qHo`s|4HHUd&B!(Ww_&)erTf(+gy$7Ets#vPB(JD<2nUIE(9g zbIdmZWxugY*+2X(L)iw~l>NSpa zq*wN;*D>FiB->d68UOMSX48Ag@!uro2tY7FKLBuLsr5fOu~+<41PBHCc5z>X-V(zf2bMerUw zuP|E`B0h?r#KePRDV3%n+%A=*X5vx>Wbm7bC-g;7zyb|zM0!$pY5abxV$zO2yIyR9 zf;RNNWQtoS0mm}d&5M{H=1cG*(8a;@3ekaqAp`no^L#4-uTv7s{@M8ew?(D>L&hvC zmJ-V_)$z|{S+nSl2Q&*Q4Y8(}YL}NI*lrc7jB#66!ab4>Ph`HZf=r52cQ8urfH8wb)z?hsRy4<#t@nz`nePtzi!?OMczlSQ!zA>}BNX|7=Y!QP z^1yGn@2dOr?V9U6Y;VF!jacPU!zvdW7C25kQj|ftnn%tQutHwz`NDaE1sMnk8e9zk zzK zpZO~$i)N*;!*cQJa^9?T=|WD3f$SEgxs;32-HiGetZ;2E)T@1z%$655_zOUs7G`JY zpr(Ska_Ne4j1_hwLI9f^%ckmRdOQAXyonpUDyzt2nmGxfY&uOs;RG8IN?LnGrnZaj zMIsa;+g2t;Lnt!^{)rO`WQQ7vGq)aS?HT7Dm3YJtjQeH9$Bw`_&h4|9KmP9v9Fi4` ztn8i5qqYFMWhD?>4mYeh9FLvDR@9@ZCOt&6Ylaui@}?)n-iD{g-jLv8Z}{DUy`e*! zn;G`Vsx00XR)^a!Oj#A!H%XlTfj2I*+wmA8`Yd` z=`MInq+Y1klvoI|B^2ywRC6{;($}e?S_#syww!I$Z;{2oNWVCS39(8&K83eoNZu&pCjaiv$#?KDXn)o zTT2Bs4P@o`igIy(Lk0}=G$DX{0;=n(Q8Q_JJDq`Imdx1(;%uXn5z5BXBoxAbMJS1J zK`0v=LfMoEMP3r3hiefyQ{bOCq12oWSAaN~)lJ-{=zZhykx^n}!Lh8?%ducjB!h|` zZ+Du0(cEimXEHD$%rPa(0nWx?2I3(~o*;H$g(gxPNRet3ohHnTr_=0!`>vuh8(j9Z zu!Fgp9Y|o;fme;9!$VH@YuN!uCWQKO0(L<8Z82GW27?rx6R`t|njP>fk99}U(Go;_ zxehy^cwz@SG3I2&T6Q3VOOa?bJHRBYBhgO84q~v<8m{N;e3u<)Pj+GlGjvc>0ntxp z2PY&1vx8Axb%!0yCw4FrJ2)w!H0l&MqSEh0;wu+Hd4ranv<84$KCZkqc zarZ9gR=d+mrFd~3tBYEn#Dl7wBokcsc0f{7MqN9m7h59>{!BRhO981}nTBv@Ene!y zTdxLt?E*8RcQ&pbZSVg)nb&_bL29qs!-}!=?fnD8;w^F{O3OnlyeO7&@bedMemjq4 zMF&qU^Kb9>qO7`Eo5|zfnjexo@wLjK)r2xV)Cr!aQmy%kmneY=92Y)i&#kiQ5Eh0? zhRF_xmsCc9y+}h4{|X|KnN~-=v>8i*3agM$|7eaBPzV=4THMU5+w&DboXlU;^FPO5 z_#dpf)%U&L4|=$+ZN6m^=N0R5lOfE?F%gc8o-BxWEuvCmH7(-C8eRCzn{J$pZY&os zJnO)X+-^R=t*rlR)wAkuH%!6BX5nDd_3uw$-2Q?)iZ3g{$Q`#Cv||L9{Y~{lj3hwU zupO^{sJZU-{-Y1?oPVcX3+f(l3NuFu0GB9K)I2VXw1lPg)ChjZ8?IvK==J%%tw0vr zw+A9hWS{&TzpcSu&V_8&KIC}Q0)=xrc-K@qAD(H&+G$E|R^nUn%S)D-5yb~t3c>!Q z3Jni5!_fLa?K?c|G*O~cgDSr@!<;s?#rVh4ub(d&c7>yXXpWHYuN1e5?4T4wz#lK0 z0)RLBMT1Cy)nWL5lx;^vFDX9sR=%T;aleZXH{T#YL0|Xjp8Ba|e^d6k^;6a++NY!R zv^c7|wK-7lfZ=k^e>`8!(oC_LaC|ibLWEWAy~u2sh&Ul`DGs1Vu}IuQ?uwjZ)8Dy$ zZ70Nmsd!L4R*DB@aMK`yIEJgtH{a;m`A|_ajICGm~ujj{FRysIgGG+?? zPHZ@0(F)GFG|3dNL-lxHr?~F`x*Csq)xn>*WwkdhC{z5}PxEQJ7DyRd}cTYA+hQ8UOKl^6$FIRi!=QVN=)V$>+$V z`aJpR)8HR?J;RtzgTE;cfowTjZCqi(E8QTCX|+=SazB;bN*yWt-y<|IF{+Jm3a}@d zVp%Hm0VatURg&dG|5k)H3^eZ>k#xMwB}Nrem&?k^tBq(FXmevXIo*KsVXbW-n`%Jm zv6kuca-TND-}-7mC%ZcGU90%C(|0>|*$65+%(R#HyG88xf)Mw5Nfo%8tZ_nh5PBKI zProI-san%r)Fl&~NyBd}%-0msqhcob#X{Eok!>k`FzrW&7-+1Ly0V@sk*KK3lpoW; zxjfym)ZmA3Bl;|-JGAsg5pBee%|xU8-5}Pc7+X!G6Ru5h@YV#mq|G8(@%f(=X|iEE zuV9!womy5YrWUBejuSSjd}e{FOnSblpk$CPEB)b%XT+RdKQfDx;4{ zK~00H1*)j!TN0VpQLXnk3slxD!7~hi1%6|T8RzNMAHOl_{ST)(AgqQ|2t8M1Ax%|P?Gb0av^T3kk_1AKuF~zzXq@=iw8W~lu3Ei;sl)(7pJmCw4 z5rZB_VOI+la@mlaLPN zognM)qX~IJrBN!#Bcd{X;#U|XY0v_IIhdlD0N>MBR6y(|RG@uCkbfu^rjDJScRNKc zvf+V8dL2I)5kNb{tXybgN;E+Fv$}c6K%i|GV@3EN-pyOi8c*p6(ibF!_Egz;(O>LA=N;cR%tm#r z5bL{nD5xGeZ?t)$hfLQ{+muV8oIo|Wx;QFTmSM_4su3#s7=$E3_~H7?z88>0K}v7} zT{&Mpm5mrl!ufO@&;a{DSCk>Z2wFk-tBU&HQqP)jcSrt;S`_Zy-iTD}P}ds=zs{=G z&1(@Aiu;g1fGcuT{J(dsVu=u0z#}?j3!L3FX?wOqR@wii@}0~Wc*i@rR2FvlRonU5aO0K&M9|p(A=UiXMTsHapC)n;k|2C?lN?fk@nZ zC(aI|&c<9RO_K5?Ba*Q#TE_+R6zY69pQ6rwP-m4#6b+qUT^)$6_3%^DDixFI5dxF< zILKFAuj08wkTsiXx+V5rYv-Oyv8#EGh)qhc6Kz?XGjdx8zs%S*J-k z6#2eAW%|PZ8{{~nBfi^x5+vn-}M0jU=hq?h@Xydp2O}$D3F1#7opraHq zN4FI*=TUdWT#T|xt~E&dp+ueBAn|zgl0o9?mGC1Bl1}Aag9Ic+ye-y9-G(*h=)YBF zA$nP}M5DlvC6{t7hb)$ibA(8X^E#tf1W*wlUvurq>D5Ge<5cnBikf0%HT|Z@!t`Pc zTBi4#;r4B=3f7PKj_{tg=@ekz8E&=XeszcSK6x72SmmUDcnq!hCOpglV^TCQxaC?r zG_+@6)}cK#z7&3*2v_6?Hu{OqyToWziO&ip>AfzOMV)wkV0l5Q&FA3K&u0eBwHmG1E!tk`41j?ya*V#hw zxBpPB;e|6w!;UMHvb(O*AW<%*VL?bnjwz@`LPRTI)*FU>bg-a&IUKzTh6EhdSMk6K zl$_xXlz+1NgtA7RT%W+Jv%Ws@BVBz$nIvZPiAa`p3Vq@u-^}{NfTJfupO|APGI5s> z2aHvuveB|MG1BTg2k~)pIx2-WJ;kZ<8TwpODF|U86jfD;Pe|sRNS_#{7#q}(tBHI- zmPo(nBjJA-`o!9rBEomAGI7g^l!>WG3-ADVp04XC6R?%1u1x%BqfB(P2qu334905( z13{OTPpo6qc`8z9a+9Y5W#sI9>0A_AbC45gABkzrs30k0R;z-TX+;7L@!E!iNCTmI z?ABoPgN_Cw_h464-7)wEX&|B)=teR7Ur!~Z+ssMz5VXP28#EFgPL0TNQd4B0%t*Xi zP0`@kW}ebj(%{HL6Kv6g6DhwMiQ*=MOhm5J;p<%*!7TQ!`la<%8Pm=Tcu64F0uS@E zl|FSQtWc$T;@Sq!DGn^dYuZ^?o%yX`gU!B8wqG?W4PZ7Zjad*x=LQIdFZ){0#;;^Y zSMu65x|i%f%3w#3H@bzjPC@9vZ#fnctd2DTR#b;1pINWfq!a1eIXy`DghfI8qH|w) zY{eV}nO=FS=G9i*5dg=Je1I`6aGEUejGvzI&sahy`X<#avB(#)I8p;DJWPdAp|CC$ zE}~DMrKD52McYRTxNI`>q)LcCitnMhlc-wI9PYOkQO%&5=GG2s2T`q#_4e$WC@3Xd z!t3q*e@B)al^`1|#lFzA#x~IuRcMSn7a61V)lXl~8lU&XY4uXY%>G1Qm|WH0f2e(L z%UmNU{#X~d{mrul*mcn@@Xk+TQl|A$mRJ?qfHi4nY=rr=wrUp2EQS72_L8JUSg5qI zG5=-HND)mpeeP91^_fne#}5tqbJzA?H;`vOZ#+xh#A%PybL5Z0XaMg?X$+sOFiddi z6Mk>j=`wh0AN&X?<8)uC@1kpPEijlCh-&-(xE|o9kFi9P^oA{t?*R48IezBTteR(n zbBP~L8z6M0jRnq2B25(HMsZkHWWjTlP{k{)eU=I)8$t)|Q=%Me{nZ=H7d1cSHYyk5 z3b)0GE5Msq4N65K%IGWbLc2O98+kJ8!PT?IgS&xpUbTiN$ca03j~{pHJ|}u;O$1f9 z1ex))jkD*ZD1t<7Db|Z1LibKx-6Plt4am)Iz?X<}4j-_cDK)C`xya3GRI>%$(+2Mo zuZ65mM^g(#{pg@JMqoaiGK{ahZ!l`yJ#uCCUcBCXUE8D21V#0~t`y~twcdG?R(R(V zRh0v)vJe-&M%c^;aq&~LZ28QCxa8yw;$myCuNINyL0sBIFVg4`7kgrYd?2p5(;=>* zYCzDn#HDj|CmVP&OI&)^5SM(PUE-R$hq$Kh*CnoQi7_-};;JE0TR~jNS^!DJrPF8| z;?fD%llhgPqq%w(!-FRcxur=xmzK{?MPBh8*+IPI34J|9GW&jr`)P_{Obe9%mB52C zqgLW#)<~8e({f>rWFetl2$dd$Q>~FJBz&n~?_8;-q{{eo!xh5cmem{jJ6mZ7S7<$v zxos}X(Nki!WDZfT*!=2%JRE~qPnc(@pv0$#qj=eI0N3g%`)FBdoHpOOp4_OORUVmh zbNjoMhhs1;=+=(GLEA+tkdO}Ij{7q&m% z->Z7CvcALS;_`uaD6Tn7T`(<3Yp8J0T5adr+o0-W> zIv}ygvC1N@tpdE&S5 z(%PI8BQF?e;E*R~vFQW#_NqA{yc+00kN6Tto}viUdzxG*-Yirqyp3oGf^K`|;su!* zMJhl5ZJ>ne06uyY2q#Iupo{r^>jsv+qSdzuAl?g@dZXgY zK?to}BCf2~gcZez2v6laK?1tqp|TC7^N{-(IbylGWLpL#O zDOp8olkH~-wrowZ3MIc}*4Mkx2n$ZIwbQ?bO`{Tf@xY~0`!Rr$xsfK+m+19M)er>o zTwWi3_-65gQbd48qf~!PM$|&(E-QXcV}vh*ms%+{Sz&Oy9oMc*qVg%VxFOQh~v4=rCiRP z-G8|%N(9ZuTKaN~MT}{h7w-^Ue#ZrU3PAY&73cOZ30Zje29=;Fe=#rSinj^$2{c~M zRN_pS=&)WE!AVod4ec=}smym^jZV4h4zkgD^n6#8(piwnMqU_yCU3KWb-YTb1j0N2 zF&=3}%xha|JhZZ^RaCX)=Ue}O_TD|(^0Tb-{9X3mXP>k8Ikf|2Q%%)se`l|no`Y0L z^;&7E6*8D#7E;NmV|20B%&hSbU9;9SQ^j(nVkVt&vPeNf5+scgqeMt60&Nh8#ugQC zLrF6&C~8D{i7>R$roBy+w4xm)%6z`x=lxywKD(|-s!KbhID7Bk<-I)bbAO)qd8I|9 z=lM7!&!;%2AN;D~kQ!l)+vnw+vR_EAna;#n{89$5#HpK@S!4$D^7HF`vk!}J&EZ^d zBuALx3j0u&ByF{l5}2ZSKTM(ahGV^gNYG| z4$DQ7FH`Od7^{BF4K3XTevM(KKZbq*CA5ABGEV-u>|Ef0dDscQ;u=FvMFoLd)Uoxt z3N8#e0bFP*`$#4k-g_w7!8W#9~4j?Rl6W43*s%=OIQF6H&}q1@sPU?EO0x>W-W^y zd=2ubX&<>Hdf{!aR{NYG8FT+N{3YC zR_Bo>qf`l)kdob6x${jK<1VgJq2mFawA;mS+$*?iJg5K@6? zw$+pW72E3Z*KBWU+SuH*FT7_F_szqI$mxA0^X`f)6uohE!a%w7I+`IH;x)6TEzfMLP-rx3z<;V zkkKuCYlh4Q;7QK_`vu@oa37Wre7HYBhy?oX#HP7Tt)(ryNZe1I%4KiYKO_i^rR3Vb zQ5wG#9nFswUreseL2$CtMS5rm;JsmIc8mSPX2<3x`B&nzf#=RQN*LtSErEDHm?h@} zxK4`wEwVo3E9FOi3snBz?`Iq@lswej=j35Ew87V)4a*H>e4QV8>{%cN*wK7#;flxu zf=LCoc9BPbbRWZ%mB!3rEIm|d2xQCKnSu9yA!kP*0%sx-t*P^ybZwbLv`+lfI&*Zh ze;5(;b(utPDJ)>YMm6Y2BsNuxMA%fl<@oP8NF>G;BryL_@KGcPj%)D0N!a%Cn#^;bvQxE z;RFTaF$KCU-2FP7piGAod@0xI1kf}OCCVzgW>C-}r2RPj;pe=heaS+o8Z1hU$_&5~ zj?8O^fO#M?SPOV~iYtWqAB;SP(Ymmah`WeZ0K#qqEVw&HWnG%1ym4Zm$g{578xd(OW@jC#N?G#iM7Z%&&eY51BOatk*RP+ zsKrd6-doR-z8q?zDjq5YL_ZE ziJvDB&RChji^`oIykr6SToXZ*l!ydTAT51Pcle}x^+8R!7nMiY5~~#+)*od*nU}@lq2?~ zwd?oSR1TBZfQXUKMWNBzM@38qS^NFn14^rC4?lP@VBkQBy4DG`VVz@4;NTmU2J7gAxMU-fd!y3{8DqbwOjk@~?5b&Lli}`(GuLU= zHVrW~wS_p$!?lGrB=Fi|A{PJ{Jh6;Ps@ypN18~`Vns?(+xQsm~uoQ@Z#fFr!I$v2v zM=eYSOD+gfufr=M*E+DXLLX$@2SfofY;~K(Wr@dT()r=+Ag;AF9I8}l zkY9-R{7NRDa(jt3*iSD>)@iz2JG71e%dXJoHDbPiEa}4eOY(ml9xtBVA$6Yu3Mb`< z;pv7>UR~dZOvyCL)PrD*XL>OEglxH(9F@GcH#(xL=47?-T=+fxU1!(SWt}U9^&m`x zJr5H5Y*E3c;#u$HDw|)k-kW>%Cf0wvSv7BtYS_Hq+y}c5TfhN>8y6-Eb{4hhc61U| zWUJ*ACO33w$?(mX)N9!qTqXPUIDMMf#$H``QZA01n@^m!LN5xB9pU2VgJPORr z2DIdmk;c~%7$*k^C!j>@+`Kw@JJJ?W$Ofh)(a7Y(^ROX1Klw{&gK7-=a})t#4+QAT zvPiD*X$Q#x|EN0&wXrHF^2I^t8hQ-!T03ZOfhP7U$!NK+j_?6#9O45~+TjDaRPiB^ zA}^}q!wmJKINOz)!C~9qV@<~JX*HSaOeClYKJtXmtA(6Nld(ydBGAA^Po0PV+au^H zHmRt8av^uF=3%SYG`0N;$*-=qKjw8(Y!aHV@Qq?)b;XJc^AU&e{F7%aX9<;-B4GPE zEQSlx>_8k`J;?#AtXUfrL7vp>H@vhwYHm`03RkcfRg1|9dG~8MMGPro6QiTk zv~0>KU^fy{L2417vhrDCju=H3@WBQeRA>)4>xMvuE#qJPFFc=wx1AC!C zwq(a%G5ZxI0E}t`02W=OE$B@_!7>d5k+p^amCv z(ZKvshD3~mcpGKRTv)~lS8`r4({gi#H9OTQvXRAoIUr%A7NX&XvFAjrSDhIBK_QRN zQNL*Iz2qu6r3fG&IQ>q%PJ+OwAB zdA`1$7sIk#UmuW0MGF|e$Eg;@_KNNY?&9vp!ebJO?K@#Tdk8kDYmGxI+C0(N6ey|) z$vUfl{8#Qe1#@a*-G2vX0c@9Nq4`ed=pbyWw2A`CNr;8n{SBnD>U-(+^h!W?o4E7< zS6Sy3i2*3C4fL>k{!;jnEimN?J&H^uxhYSjg8LGn9^o# z(Vw%igvDxX__P~KRG`KNXK3vFr*~gKqkp(5spx=Mwg;udSK43YU%BUdizQj zpO4oaBtsSKQqR|#Eq)_e(DviR{=PNu?~`rRZK!Xnk@2YUiwiwug@G<3t2Et4u%2_a zd)wLW{jXrQ({{GR5&q7v?Nb{?fd?psHo$LeD1;a!hvpLbwHXR%^KD=It=VsgLo2Q| z%=X-$Rlaq_V3=h{?5rq9qcu432964`RC&c;x#{oh7O6qafAPonoKj@8?Wi5A2~7?J zEH2qbAh&EIXcUc(4|0MJ>X&^IGMEnV2p`xD`jDA`evJPQ2U)*wvH4S|m%XMAo};O5 zpl~B7r-5OD&8i_Y0*1WQHN)67?Ol*w)!O+3fGGn2`gJr5kmxI*+*dn$L8*58XFn(2 zximVo&kF}Ivy_9Ck7+CgrU0FVLg8~w z=%_=$Yj1yPA6>}eJ_qJC1jVF)$YK{7@b~_au%0Xh_9~L!LRVmhwowoGKGN<*^)C0C z(4RHc9B8bEv*&^Sw5RppW5r@G&FMUvTea97z-6H`*u}ZBB8#AV+T9qnKxw;L{_@Vd z`#L%L?PYc4PFdgKLu)w*3iPgw+=zhLowhO~x4uVAQo5?La!KUam6eMzea5U@)sKYr zqO8E_`7-%6ohj9As45%vMyx$JW$c<2zose-(NFBYr1N->=17KUdRD$q%Sk$DoTF>u z3x(~5k=T`%!I~(FYigc#T#~E;`>0XNRnRCRlnMvYIL~lMlhhxMYS$Twyz4?N?nsVS z<;gK`*S?J{_VNJ{a?%+-C{2z>vH8TmX;EE8=7ju7VN5$GL-f(uvl_Adrfo5twPc|7 z22JGcG%^IO^Nb@^q*qgTHDg5A>Wx$uO{kG(4h0nCV?N~PL=0ACa<~u>!o{VbVNHqg zQ5xe5Bw@#uMKm*AGKk@t`}yfUX+uE9|^8w`NexU-lhNrZ;0R@`$d!P z$jTpLOA1MfKlvu6YFDTMb3`~)sm_#r1FQosH2J)Sv-kZ3PZG+aRmM`PmnnUE5*#qA zAXhg9`FVI!ex7&(FO=U%^Jxq#z18Td)o>Nrf3-H0Q23&O4q%6k0zL++*7-f%mf+TS zXgvy9gxSU-P2O5AsQU}_&<>`t4VwgyXr#HSX#615cko-7c4q;ldkFG>(I<`y`4>cB z1D~yWf|pMd6Htv0`%);yaC3bdMsq3RYTuHP49L+f zOWYv9V0|O_kgMIsv~X|^$GfY($k4KBQHEV1^wktK8NJ{Q?n2wB$HQT%vVQFZO9fN> zef=v3>lSA6da-nu{%02p?ReO7h=vabfDUr(f5o{^Lt zwrxn6m=Fk+m`+#3t~3>U3h~VxRES%DJSVR4k>6&VI*U+LE*Z}n+N~-ak$l&ccP9jf zk`s;YgLD<-JI_Hl-&wqf#?!Pc1H2RyjN;?JheTOiavROnY%})h?fnU_^q*;b?vpnc5m%x-BRyL&Lfgb&#f zebD@e-+KK5XsSs94&~Yu6@(sX=i(uRZ@dp7ei}l9GeZdWVMv@0gve^2P`GVA`6h>! z69lE*3)rAHo5A2^v!Am4pxZ)U=N^OEsv1B0B8Ag6O<`dn$^jSO3fypUn@pEjiXpd?uSRf z4(_p1W!`oQJw{w@C=MYi7j2c&ckj$oG(}3eIN6kYH|m}!nFnswn_>EsRuN~Xcvry9 zRT(0ucqwsz#1}>zZ!7D%f-ek1@qyWje{zpM2lNLCd$*J!_(pL}Uk8F09Gt7zB}xyj z@W#kGPt#?=$SNdxgENJeW5cfyjiKcXc569S=|a(wE) z_;BlG{efKhsA~^zE6sTWVO>gCe}QFar1gVI&wYT;R$jlq_rSZ;1Mko$(0>nVuQTGx z`T_R9eg3;8wBMwoZpC)XYNHd{_xaIE3#`g|eqq*XHt{o58zt5@|4FWVA#ZdWe!M3q z1VxUVX{7ya+1(a^HhO&_a+;EQgYf3zyinH zN5bD{Z)WS`)f)AElyzh{FhveE8y;X@D^?tKk;rIg259p}=zLgA1PxxDc-BLH={fd$lhf<;L%10*S2sf}ES z;1+^j`2PA7wLnCWhKPs{5fL9|Bg{aJ!u z-H>_hkV60$1cS3gz`CYk1~jdKoeLVlQkefj1Pre^5il)*BVZr01*>R9H&hX|7dMtm z%x`5N>wE^WxFq~i{ECk$poB-l*V4K-Bk(#g=B02L^Ick&0D_w1Ue{bRSgo34ZjxH5 z5ANNL7$zK6^ul3W=!e6KHXPRBjjWu!4TrUhu@uu;42P{6aT-UO`QnrU=&uooXO!H{R8~nVMm_SxECE)-jp^e}ou#=0Sya}Q)09basNO+`2}Iei z18Tde8H_7uHi@I$&dCP8OZsPVO^8Q~0f4fbT3gsGrSd#e5}yvV?=HiOsG7jnWkfqx8+mIo8NwV^XdujCjkV3x(b|0PnFP_=g6a;> z6VK#B`ZgazMLwib@Bu1{t)eFiF&q0=4i7vO@D5Z|g)jKep@<4iZIvnZE6s#25BJ3E z-%9OXHPGF>Ww-Y7OWFkvL(05*oy(={TWSHJBRVAr#)+fF=Pkp_al2rdQ;-q6i(Lys zwSnC(gal#x;`PbxBC}t<7=(sOvxOMI#jlV8;)QGn+*%yQ(z#v00Cw*VW*^h^?D5Iv zLV#>v+}nYe%|7(q+{aNG&&e~4aOaPEu2}fld)}fJlx0&252=7o)r8|p4XQ`v-7|<` zxCxwpv7N=#%WIe`9AZ1~gQ5Z(&$@LYYm(L_`m$+n>qIu~ZJlt%UGU7?En<(myx19G zked2D>QDrpU!2323vl zQ-dpi`sus+j;^057Rw0~$sMQ}Y{Qo98fHn48-f~c-!(Jmv1-o6*r;mQ4+M8TeUQAF zv^{l*yN`>0Fl|pwmw59?pwHn9UBns|*A5v~n^)|nqKZ%4)z(zKtzNY?m94bwy%a91 zt_to`UX!ymf2Fo$Hnl5KFIu|WPEtup4*~RQeKC3vccpS z;fRsXwRV3J_otRnyviI^ z4vUYXxTXf6@-aNf{4DlO0oaE1Gj}Z;IYn zBu#{i-CjUvlNBNCg_r&|X@FI*|5n2+7|-qmNID0a(s0*VY?-A9oF?|P?i^D}$*4@% zfp~DQKCa5RsE;v&(H3d%d*S>#g`CzI!tCSXbwVcg`yX;A&MjkivApc8Jl+&eo3Fou z1OYzShpgA=X&t6G`&GRyDDd_^{fT(`IuV3~5XI!@2JH7s$v@hdK8iaG$SS`!L6XA* zJ_xQl=n(hxoGpq9BWaJn{VZ!qP6KD2VO`L#sb$%d)ReT;qet}dvivLgU@vv#OYf)J zIi;aC_s_SgDZ0CA9P;Q6ZISqKFg~jII1nEkwV->dH#k9>GgxmO--3|0_wYKICzQ%z zn%i3?Aui!t&ooqlEpTOBF6xmAKYb9kgy?;WsExc5+?Dlv|`=8U=dmf zT|1&d;X^;19fC2Thz_EiE9W@klTM^{f}bhIG!z+h2dJtQI)P+1JV-L5;snaj!tCmA z-W2>HWgk`%_)zDoWX1dANR8rl7;vsAA1!Ob83Wre2y-h?v+wyX=2fGVBpwhcY(lXI z%trJ2enNyCuCDo;ntiA#8{j~3KV_&s5X@fd7Z)iDvcaBTBnqRYb0tqQA3&`wmD^J# zVTb|q^!@qvCOA7}Xk#8x8)MO)H^OoqD$%p+l)2xK^BJrMQ=iA04X(;&d_Zz+$c<8a zREB~fxgrIw119Vc?&P7AiS)#m-!Y%uz;!CJaVh&I3Y4%c*|D1-%;IK{{0eU(O3?UV zB=F_+&-)9j4m63#0+3%129Vo@`T@h@gZ8A0g^T`~85e|d`j98A1VpWd*C6FVz$N4x`fF&=Z>qZN-^zm=_7U2RbtwC&8|vJ&p%fsrZ3-Bh-q)v z%HD4SyekSZrBNmw()EwNdUYwLz0DC1=Pbp~qSJ^xZo=RH)f$aZe@&@#kny_7waa`N;>s{gjM%_W96dDIUveA8inM@2h8tXl;_}LQu|7@9h>Q>U^3!~{wVh-+ztNUw^?Zxx07Nqy<9tpW^Kr&pgkburT0HhmI8td=Ab zDMOagsI3yt*y0k-YaK^>rQT?gy21p>+k|D8NYuW0cmX5`xSu0J#LUGLq1l&%yI>lWh{h**E%b^* zmiPf_mm-**=9@0;gLK5|bPz!odibj16%>fr zMB_jrehGG@U2*dobN3=Phr(of`HG1lwU5sZQk9n$i91OK~GuRg_3p)XmHDV%5L}6dXf-< zlGan!FI-Oj{VbFST}Dauc21Nu)Xz^(vD9=y!K<>pl9Wl5 zYH9sTaS!PWh}8Pa(HB@X{;1{`i`cE-5N}koe3Lf}yS0*TncPLJ{24jOT6hzQ5KFD> zagYm8D`^9eo>{Fl2idrA4zlLuVy~J|c9&YI)8kmKGpUu&5C^fhOYSPGmHv=Fa3p1N z0`>Noiq80eCCFW5j)E6WV#ybKXUD);aI}S!*B^MA^b22FaFkJS6vg<1qi}r{N8#Y* zPESQ!qmLd(;d|mJjJ4q?dSaQMP#s=K=P|TeD%zY_2Eih+4Eeu0l=GoK4bH7%8E+nR zyQ}eU57V=-45c>=>n+^eE$5JU79lP>wlUxvVfGAij^|65;flRb$M)E$C^;sVf|cXe zu?+_kDx%m+m~AXOw$HPirAb9^tCX6{G|UF9 zmA;OPTMUIiEckDQcMEe2Mubst$h_#qGN@cs(+{<_3lFpy4D3Jfxw96*Yk&pr`ima{}8O?Au^uD9+efRQrA$4gXxmo-jb{Oq>$oQ z@&PF_ei7J?uv+Bik19S6@PToqQ#t67qj$Vb617oL)7BUyWXjvPg&}4jhgYzse}3*^XDS~ElR=_rrT{b(jb@V{TI&w$)_&ubdf74?J4?Kw)>tWA zdMviEU?t%B@(p>-t31M)*nv;4bG#dyq54Cg&Kz1Lxg{t#XT|m zbmP~hHP*3>vA6~Vsz?Mh*0GMqQF)n5aMmV{G2gJC#5G(=lc+Xkzwl$HP7#rTE|j{U zP82zJ2tYv6Z<*o}0fZvtA_$2(0ZVGUfl(@g_0wRylW7CyKcA$X+ao)Qflw+JQMBbE zd}0kZUhU;4I;K-$TrR?)Q11n{yn%mdQG|hJ_mV*vWMa;iGaskOa=W|9>vKZ_B%K32 zA)Wl6kyqd)VTYEA&O3Qlg2c7YO~Kr5UXBUn%@K*aqId3nyTI)8pih4e(+aR`7JeG!(`&#{Ux)Ffk&&%l+u?>hQbZAe$(rynjj50@{A$*T@-NJ00R zn`J)dafAa-uXf1C*x3UlU|9*_ zXFU)G72ER^_$TZ@5)1714NHa$1PcD@5yH;bc(?Z@~( ztaJc8_ganR@iQJjgwsF9ACHL)nOG!6ksC$t^mpt6w^EZUfYVl-l${%DlI_zR;K!8X zd;buq|3X`-pOZdklRoIgf1jmK$Q&6P&z|&&0OI8-eLj2nNuLNAC8_gX*(et_lGoZ2!14e|A?6FymC}$))z*Gc-BSeicZyCW?>ot)XIpNeZ9k^f zmCc}i!WdLiw|Z(U%w2j^D&d4WP4lXEgE|p<0z&5iazJ9V>Jf+hxbBs+n2M%oNRF;DM~z5Zn>}Pkp0+mY42Lj%v{gWZ?6x+m z)oslUz^H%>q6+x*XVue>JcjmZ#$>qXoyOktZ2iQjvr2TX^6;P{U;^0QT~>)~+N6;2 zKx>s;C;2P)jI0tYEZ{Gz#)z^K(P(;Qqzs7gBL|f!-dn0ITPaHUP>qGP)(UCNA?s_6osj@a z==IDdg__zfpp#@$Ct|56zGf$gho9}z8LkH4+Sg&rO(%_Xx{B(vDA82 zD#d@3`@?3%fd#Vy{H2se5Xa)AUllcGTLu`L37D@~_gVNL2KBSd2LYK@k%5>ic2Hg5ig2LL>g(~q?<}aL*-Hi; z#xmC=pqqAp+7(#707_s4S*+p<>Rw6QKQgsqbA5fE_GtL2`cyG{ryx8R%3?fX)i|@) z(!~xeJxkuPt9FihN8m6Ed>(8v8+AwEjI`@a37C=%(F@D3s-4tC+FiAi&Rw>%-?=14 z>jJArb}|3(V|VrQ*I%sW68t<3S-o}~#vG_Ul?>->^2=u;1EHG8;6I)(8Qk+1u0FX- zIJ1vpNjN`EjQ{;hgYj_fON;Rx02eU6uQhg(h<#T#K2#QXdy(m54o@Y{U zw1t?*^||DR6X7mOZbT<%lN%Q&Hd3vl#D-P~j&s#II+rNi1$#mOzX zw7Pf)z>8#{?|;rGrx@O1f&dwGmy1shjCuxra!by*D0q5CXPliJxN|Iu&f$zx(&68K zXWTRDy?M_CcyF9Id{J6>^l~;W{35+KNs1&6^ejk`C(c)jeB?PP^7Pd34uH=|k!MZ~ ze@==xTk$z5qM9B3kWS*9iRvz#bDlFK^#7hO=ls+P&UxmLP~;JyEn${E6Ct5Lzcfnu zB@YR8P+efB3JJBT7|&WrNF_)kB=q`ox%QlAeNjrqeeUIKN(G%?bVw+{Zv|nHe%gRA zn|y0doi>zHP9H2u33QIYjd%Ft(HkiqUzHElDpfE2KAYXE`WVSNtFnjv*y)oTXXE%+ zcFX~)zj)I^fa=0}c=NN~!+jUg!^^$@7}Y!%7zmoP71(FM174CrI8|<5JftXoAAXPB z_>GixS5nM3$M$7Cs*IO_+haH0>4cz+GBB`<`mWo(jc4{`9E-&!q=@+|Pt~c3I>bwX zI$Rhvr50xI(OGPh$-T;fO~KH|ddFhX5mKWrZ?;-2&VIK2m!a zc>Sc#ok(X)-Nx@DM7xskPUDza4W8HZb?D*Jol8)<8*ibR>DBnl=27eZJSj74m(X0*7QrF%Qzj6P~%Z< zY9|=)vod5<+?(@csr=&JF-VX9evFm{bP5&|Hf(M`{_yPoX-;}D2#B0ITh+I7n$au# ze^9!0$bsq_^1qhpC_zFqyrTUC)X*W&E0Euw%2g;4Ko65?d#g4Zl=Y3rXI~V*)}Fcr zAnp|kcrJXV$p9$5EI=G}YD1e4#5`}+WN!M{MV!vAl1c0!-i~TdJaa?+kxYl9-K&!q<77bZztfwV-|R6JsssLP zn?GQXDFI$9E+My1md-_Qk7p#?(Jp0=>a&?>YAQ=Za7Q{3J zu_1^Y83WbYWFiuN{4Sn*<>a?|J3OD@yq6+9RT%TN`6UjtVkAKSkkj};j6u!Olq?gg z65q<%{d(|)=_zfINv}Y`!Xy#PJ_AVFT{in^J?`b7z41Q2#>te!`dxSHFp^);fpN@@ z`i0~-@cw8%s1K<086^#ULM2}wdEUMMeE+k!a$R{t~GE!RF%6Hy3Hbl*PdFBm zXSQ=@s$4`NL|&iHPEt`>zc>~^`5uG%r>S29_OsP+drdQ=14=o(avpnhNeE%)TsT3g zy^0-~Y-)Q={b&Px$~+CWGhUIe9js+Qhca@!_`~^LaVa&*x_j3o1@gQ`*>OKv`SZja zxlv7YEC|gUryW(Wllz)|9Qv%v>-nT3GS+J)k(GM=gyhXgB(Yz6XV~AzF*OuGx^6!k zhA3;n_w2g;`c$<*#xqgw*{GXBHQqn@^z({!s%`W{%HW`L427_PwBFGra6?k}vu_ay z>g#D2(Cpv2c-1@p-DDr zAi5j*kc0YDS;#0g7LxOZYM?H^*~vji8CcpC#)?8AEUKX9$&y!gO}nE4Me|77>NIqA z6CI|lPIo>0q3lAQ=Wm{}3y0dDAIX0I<7n(wh?5mO@*&8_N)|nvKK~bEY z;_KKRXz&5K*^g_7n5f5f(YPt5*8yO?elWiv2|IS zUR&Ms&>Y%j$0(v<^C9a6bo|nr@3VsRwSvRrS>Fjmi zAIsVHBLI9I@3GdP=p5kOS9m{|x8K=BABN{evwmX%WtnuLjv00R$PXjv>kog76>-bItHE)D z$&r8#SL7RLT58KLJ$nnVKnowxqW1@OVXUNBVkK!ntjfP3ZAL&F z2ULT67T@`e4iXsals^KzGNg+cFn5bG>YCt219nOv# z%h_d~s2xywCuj84uz*6mp)Y6I1g%N_PhgeWX%2u!rRqc9x6-*z=u`b$EXP`CE-yqr zeV=r7_0XAJ%;}_EANPI#UD98gL)1{Fm(EuBGSHLL08hW=6zhQv|0y{mCQl9WjmCt> zXe$p|-C}x!R^{>n&VH@IO&Vd@>jw&3LW~`@b)71Yu+{?`U+kP#E1V7|iqJL82bpx* zG+lE98})$lY;*ouvGDhxP9LIzdZS zbn@Bj#oy8RQ`u=_&lhEkNrBO*lmV?HDN)Hk9!G2yvp>*0WchF%bA$n|^9+zf!IOQk zR&f{fmq&s^bJ}p^tqL2ApVan!uIH@f*PHx*t&Ho{+ShLaGd+VAWAiyG#NB?<&{#7+ zXHX1Xn`yI?^YPbjVlPTOOyk9wu#8iHWgAhnPrQf{xgHJ{&mEdB6wI@#rlcZp965|7 z$|$Cqa$X@gxRQ3dPgN-o=|%A>DNZ1`HrcAc9sU9h$EG3UP2IY`(ty(dcJ-{Oxqg!@ zS=AzIP1%7laQ9yAb6)vPVP9R?H4>Ym2ijwt9nRLk0@i~=O_?297$|F~ak~{GTpLh8 z5LDw4j1NJNBc_i3Gg(iOz>GrR&Bg2@)*kfjbyka26J)i>>078)lxiezfa`4OVG(F( z4sfv>>CxyR6>AKPGdu&FaCxl;r2l1i)D;#FJzc;5;cJiHC8s0<2;N{!9s~;SXPbP1 ze}UQ=-nB6)wU{sn`Dt`oCGBYL^YIDInR^1kTuA)dlXDjR7HmEmn6nZfz8o1)ay1ft ze+cp2M$-xOZ)fz~G4uaf||N39O?X|A~t~rMq z2!vm|AD#q=Q3)Cl`$2;k7F!Jk;?cs~#nvc*ZxF+e_{Pfu@emxNX?2u$AV#UEh9{81 z3B+;VAjW~0hHDTH7P?7FDQ$^?@E`PQC6Qv9>J492E{-8^!%Nb)(pzjHAw7>W2|Jrk z?#*>bC@!b4jC_wrpaaIL7WC|P9{4VnB(JYN7FAVPgnDYEYIz1#mA7`Qs;wU}oBUGY zg1PGS%0_tKSJ>11Z1pLRL2_j;s2TLfDDJa1ZekBxfNSzF02kpP3X7ggVkk8eE7zA( z`F_zdL|&MGnG$F$8@c)*qx5l!!%DS56nQ5%gN)SD4`k3 z?vknj-hVPQzPvv88X$QbJ#rg-#DSlXKC9PmnLrTZbX3%pA(Nzl717%sz(ei$enN&u*+QSA@dmAUJGrlZp zWGt4~Enxs&tbOT12pSxAs$P?Y7A0|F-ZgnXD6Qpk3}<$)8PI?3ox1WEe(53>gAU9n zj|$E^#p5G!IUtAXo+U>uLNZEV71T6qs`*G7(2KVkCx&IV!N0h@1G>`6rzf~nRsZbPXuCRga z1q9DB!jrFm3&dmwh4S>9It>aGELc_5`4wM>>DeBNV^9m$G}t~|9>stT0GYb7r6mKI zGuv6PYVeZmikD?D657)OQeUi?eNr8$w{DGLapK341COi5;^QMG&A`520}EEII3)~E zf5PDC=EOGazFp5ci%1sjdOCkBJ09qTQusr8p*r3vvViOxq+2Q{rlEp(LG{UrG9TKF zB4Za&-(N(i=DuQ^VOHD|fy!GVd>0#@eL?~^)B?-DC^}WvFB0piAJ0#Ujz!6bum`0W z9+D;B+EDrA-;Ij08zMCuyCKp=e~4ZI0ewESx1ON@+B8s&Ny?1JWdP28!$b2Duq?ZC zCmhb95n5v^alUS)ZwCFr_;v$MP0-W?`oKtAg?H#mGe|h0QPBu|a>Zz7zpgPDcsepd zScd8;ETfYd;yD~vx&U~EYz$ZOEw4YWum$G+L*F9+yWhA+JM#F#VcMb1%ld&)#LkRZyRKuP)S^h=O1200updLX~biiAVZ zKvgb5bc~vbzx!R!*wH?mhsNd?Qeos1eMbt$DUsb#(r+xxo?<0aH|KjWsr7$=w zDY$^(5kQyXi4LJ?8+}H^ALH$%rI-6kjl}PVhnR-t<<~;ig!{!tSlZc}1$`dv!^A#A zP?KVPERzVREpZ8ogeUA5KXX^#6UJlzvo$l$4Fe8LOj$J2$jXOMTXeW9eZVaIrMz~0 z#|>O)a%;#zVpdjvQf`uRYdGJ`6-Fn&vtCR(nnh_TgRRgLTq&xL0U3l1EB}#ydoKvQ zhUUs`RNo4hk$3`3m5T4*yGJGYz8CUZ%~GPJsWqT+b0 zW-7G4Fqshp-m2QBqic@RdT4u6Z7JsDQ|RcXnXIR($e9;Gv*ZUMDgLA%F=c*8HxkTE z-U7K#d()J{*HH%C>^O=H5`-NJ(px|GdW@7e{}d}OAZWFQy42mfix1ci90CJC>Zb1Wo>TQhUg+doL10D~sEB_BMF|h>ui*$!}~F(^aC%m;--U6f{eMhgDy? zGM$eWuDm3l&DUD0Cz(#d3FmPLCsv+yPNK>3&*DmuH|=lq*_LR3Q|Pm?A5$0FhhfU2 zrd6WgL4!P7fjnD69?POZFxxG_AzT_&eB)fC$otb3k%cZ!^+T?!Jty^Tt=f7?-Uu){ z2BqY!-E6o5X*`^nXaS~Z#HKN8vlU>*tQ4@1HIe|^!|H4XW^qq`;DxD@uNVT1ITDyS zQ4R1ur)dJIg^B85i9KogX&SL?%-SOXwx`3aX$uJE2}Scq0V2bKD^taW2Kc$12HApx ziv|Zz=%}WENWp4WQ-H!_eGzA3j{{9>O5z+` z&BczeCw;=^JlBTX{hbz|XM@J(*`Tqx42{5mixaUAb|UtRgRVg4>CU?;hJaFGpBOue z6xqgxK7tcuFSc%0tN7j#zTtFZQ-L(HD;uixI_L5Gjxl8`ka~z%zi+|x(rMJchqk&6b*n%qZkmChQPye?C|EHU}YIplRVWM~FH)%j4GqZ~bYmnm^50K6^ShLNDr4g+?Nma0Da zX5dIRa6uoM9Ich$tUQ~vk=4(y_su>mYk3|{`DhQ&;0|JL`>;Q=@O1bCPo^TIQ$EU< z<=hL4TY?|Ef9>Q=^$huplH@Lrs*6x9v~FP#H*Tc9gQW{md!)SP=Na&rgm*=9P-_ydHH7)k?2PvAGu1XTG8a% z8>~FPh^uo;zjrsUs~wH7uCuqt*2HL@yVXz&Z*z!0a^6kZnjs9pbZFWPU4yj<-Z6X7 z`(?1|fQA0(weZ|*j`Vu}I)(ige@o|1J5LfIhv-s^&mhnGZK!R@xc)U6<%xa73;{~| z&49XGH=KE;7M91g1of#WO7f2GEiv_L($dQ2a&dA~@zyIzh>8ctC->`k23|UdKLJ<_ z>RZu@ae6A)jDc2Y?}VpK&$I89F2yowc1Cyg#tOYGkM;tVk+Bos+l6V{NQ+~SpH?%W zo{k}rSC|%ow8IaFxFzfn;vLehz`qs%;zJP^mbx!g3{-;?DP0Kqp1t||#3ziZ>9uWp zadl7wUpT8hVaC2@&{OAbLJJG-)U0)<#t{G>{h+?_WHk!r(O)%DxB&CCXC|1jq|NN+ zz(+1;=Ev0T(bQti11XY+xmk&X$0+2CjXgBX6>a!k!s;eHwOzs{pJ8Fnc{68L0o;dR z#GsZi9ZW!rPi$y7`JR86Z#4;p-MLd@L*0LYIWqHCF(h3V?3BIP9HWG{R1C>diknkB z%gho`2qADWQ27%ug@=vNY?EzRy2C_*YOv3chDzTZ(FVMXge};$Nm`cMUSvoPWL!2w z8U;i06*D9Z6EP&iqG3pJ9#6-Rw0wPr)N+LxuBh@P%csTN-std-_44@EV4|b?HcIA- z-R(IkPRAj@1Z0@85>>fAB|fiwRd&)y-Le~8EqO`O23$Rn^Tfg9kXHDSnwJh)M_UuL z>zvFfQ`DUXB8GwR-evK z^8Z)v_t;4p1q@^Armrjd;L*2c?>ZOp@38gA{+;=zg!bB;fC8853WvsgOXls`{`sEp zYT#VpaXD{n?kVRK*v#a!uy)) zG8Qe29hkLPq}0vod8p(}PHDUA{ZVV_U=Xtt)!Bw9pG};OB~aJSJ~Mc62_7`tl z&czcF7&-PsL#L14i0mKj-O)-k=*@$ELz$VzU=SYQOkxumVh8jLZl5?A%!+SPkacg? z@jB=ST;9XWxXa}C8HE-$A1MGK7n$WVspUUII9TzCHJoyEf4u`wH8_`&$XP)!j~N^n zc5bIEo~gD-80D%x<`TJDY~VQa9R=d_qm)Hobno_IFwti@o{dW^X=VRsyVM zCm4MLyFO+0aM+nL=Ru8XkKonJ>~oqKg9~cY8i+|imy62HS|jM!Qy_o^1QLm(wvx<1 z%V4^#2FDK+kv|Ujp;&g3-8vy7q|5lHQESaZtV`KLhMCjK^yDE4-$tmj^-op?ne@#d z0(G%X85iS6_)`+VV%*9QE%S?rbm)6#^Nqe|fmxyC@+A!miMAujAb|*{7f99@L9*U} zgp(zuWUT2?>w6oa@AZYE^}VIJb8NvgJ$G??DILxH5h`t2d2LN+DPEU!LIB6wFaSqW z1f3X7qZ9I`Fc^5Sy|P|Ap438xf#`tcS67;r+YsVFZHb=s3s|sRqJl)qI1_zYt8G%2 zBszammc4OKQcgSjTT;dZ2~rj-$4&q#+{u&ZX8LE;$z~`Bv2co`ep4CrnN)pN1+tQa~0#E(q zCbDDp1G1Dv3CeEVDW2Ta-={XE4ERtTwFoTZq9XK9ZQ{F`d}KhHeM&T2NMnrz8<|oH zPy+dySAD7^usSVutg*rb@=B4slJv|r_jbRsgmWB3Ua_$Jm=TRAE>l;Iy`Dhm$vlrj zEe{H|b!3jhI;Zyfg~q#`$I^Fy?ftXEF{uN&guB=)p~hB0(S9y2w0Amn05x>!x>e`x z9D8-3vzoBD;V*zp*+-ND`j;A=aKahfjcVd?tsaZgvR02J?(7~*cl~T*L2h^~EK4qh zoN2Tu^>n_|oK{*^K)08I$x7a&18L~2-98ADIS3j6lWcM|D9a+^ngwog2o$X-Ey?JL z2UqzVtUZ6=e5z2>9sxBu&ejS##$T!@NVC*ON+`!LWh)PEV!us7ImS|xP>u|xE!15l zlwLm*?2Rl|ygHZuVbSqwTW1hHmAI z022r@#y6B}ywK}1(3Jglu+}k{M-Vb~;nItYvEAAYU>y zIqJ2F#F6FgTBS_S90jzsJn_4&+O$>LMAMjJU!0PP+ihC`Weou+U%-wneD^1`W2@J= zuvc)CksFi*9g$2|ranyS8pS!cYY{eyWvDV!CmKD1K~x#jdCdeZ{}bmW8Ue@Xv`dbqp%o}g%o}2pvu$?QE{|i`wEYvaVK0wi<--*(OmMr#}V@?v{jgxNME{tg3D-f=L^dX2Vs-QRp70GTAE>N zbLc?xBMCODdva8eZ|n{Q$3$e(lTJDHQzVNi zJre_uXDF~y=^OdP($1B9LJLzc()8-wjLk?AvhjrLXZE+M%EVg}@?oWH3|~}MDEiz2 z&g!43?RjYKcb#fN@8MAJI9M2ZRM3v~sqjAO^I&?$KPn9uwP=&5!kiQosAW?;1KR;3 z7Zdu}{_U+8>6U26$t5G423r*7f`PC-=(`xAZplj1gdC*MHhGx?aDDkV1Uzzsypyqa ztJJN+x2Bex-CG0QDt*hx*!SL2rX<^&)L;}x>)sma7NtzMeF{AjX^OZ3&`!u(= zfTsA+oMd16)pcn&c2+SG>P!AHV;(+Wi1KJG#%F&uTQ zK)dd_d9AD06E6>U4$ZyCd`m+z2q8bw9UFV$aN^avE>cAi^0X9Pa?+lgre&Cnw271R=B0yAn$XaoCCB5Nu&`A5i<;G28sF!`zJ%4udx5S z&DoS@Xlz}2$c6b@4}_VI8VX(?;9L?D0ft2}k!)MPB_3lRJ&;P-4O=O@p(l4lR(npS z>;^Ltd1|^>zzQcsNbBLBT|WI+gj5DEnYUVt=v7NR>V#A9P2Cc21uHwx2at-E`P*jU zt3pN88>GqudT7O#{xR_0==(1b4n3#Gc)@>3pg#PUNpvtcd>yoaO&?AV2H|y@G)@m9 zK52l_wMCv+8mfHgtoX9bOK~f@=l|DJ)}Y$@ zIyDPsp*3u%Z8;{Rm+dh^Y}~m=HEBNvF1sN_NR^SkD(QKGw)jPM-2cD@jcd-#-JnJo zOAH$=BCbCg&UQbDy{hAU>$rnjKO&RoVUEM>*t7}58LQ@E-#*?jzQcXqS z+}G|Io}FqX$Tv=k3VtK00a8??;xVA!tyWQ)BvIbI)ha5JB+t8Bt)enXib{8@Ra7QP zQR!~AipnG@D&4JCQJEw~#kWj2#xl!_F*C48*)a-fmIvoC)xaQbD~!l3h92XaQq~r4hC1V$Qr8x5hF0U7QrOy?R&Ls<3!lMJPer)u zgc8Yo=z2zGzkCaphI2f*^#5~$m6pfn#ZEA}4bB zEpBO8bh*Dw+_!}$CZF#9Bfx1bAFe z)YjcftVOqi*1B7Xwdht*T6Zh47TpRu>ux31qFX^_-L1r0bSr4AyOmgrZiNlxTV^fB zqhtf&esU5VbLH|u1*c=Dp%4LJ=z257U?}a?G&@}_x@XhGbhYfRra9^Apu3u;qpQR2 zYMP0zj(in1(VGU>K{_WzR@QH~rOybvKp(Ed3AKY7O55qEChQ&Q`JH3kk$+w4?45OS z0nK?K3m^-fTG$u=RQlIy00vGns}jP4eMiNcTLT36GGMqGcMg&CBA2Nyc>Kz~W4J^v z8GjfcV6|s5xXQ zG?d=9BC##a)sqAxLcdM3P-0u>W>Tgf&DwqtVg=n!`kENhzi~4GZt+^tz~Sy5J#kL7|hQckq>Q*(oErqDLbIyh5(~9$C z!w*S@?fBsse#ouhhgvoGq2KlXSxwmp;ZXoZ`b+%K${3*OlrceAgKhXBFa|o4W5E*1 z*+LoHB>72vvEqx!TT}Kjq`ZScC}Y<2#SsH-clx}t8Vb7@sgyO|w?7nwO&qiEfB`Po z8+Ov(YB}a;iDOcDRVo~OL@Iz)xURvLV^Y(4=~l}zM@t;Ds9TOXTH=^!-|9=OX0(fA z8q2JVNlcialD5Si(&qY1Gf2C+-Aq>8OtUxLw>KAA=+ezaPP%k+k)bZ#T;!`uHy7D! zcXM&-JubUrGTlLZ2Ja|Q=6g(23YxjdqJkwRfr7=PgUl;YthFjW(T9>&<&v-mLvxx; z?w?T}DCty>Vw9HYPNP%FG42>0T!g@sS}|9+u7WeiCWsPlV5N$?l%eLKmVsEQLM~jb zr(ZQ69L_$2bxyvlRISYv47V z=(4L0=F{BiB-nz-F3r4NKYlnv@XGO|OOb)ryC^<_D3f<@8&%WXjZ6INC)w&LB16gX zMN>^$QVZg0ofVfp$xZZcz2JXj0{L^#9SOTycb*V+(vmh|_U4-CTaQ*&j51rM1?Lu?IDM=()tFCi<;HE-7G~_(cQkm-Ye2= zVq#U)7*elL3V9!$MiKTzKuUX+_|{}aq1zY=!n^GPvK2b3_DT2#2XY_r^MrTT7k%F# z8b!}HI9Tuv!Xd&pxE>fw5uET1VzbEYC0kCGO-hD}Oz>_koChO6mgkhF=k<}SN$Zno zeKZqDJ*^LVQr3Chtc)`oZX>9w(YD_xwlyJbt)Lj{96lkxpghiVq_o-wK0NGiSqXpY z8U&;`-*}AXaOiCFhgRel1gTGOgI}CvA-|x;MdL~ykbjRR&(>g0gN)XwV=t-)1eWW4 zov*_zOu0e6J)GtK33ZE^M$tkDra{f3K}~5*OobOsfHOy=I|Oa2TpHV7iGgTVE3yz zeJFftEh$tOnJ!Iromg06Xd14NxzEXHl<8swNdIZrH{Zv%%>KW~G}Wxj`f4*BM3IEc zTUtkl=rt39=!5bEtRgB1zhOFZerWKf1aNiQG*L(MY+qv*_9z=G0ODFE6lD{aqVCTe`*>_oo>^Bdf$I_Tnsv2 z3n^af@lF9E(VAw5=rC`LpRxd0^_~Tgi@JDlXPZw-2h+PAMJdC_C~cesH^`GDp@`6; zd~-+|`;xh@lp@5kVuX^}`sI+Qx-}{4hJM`29tddIIMqGB`q{OU8VP93NHjK(&SQ!R zEVy|z>|GPGo5vGs{JbmNJf*ZwCdk4>(G6jfj2db9yFJX3!MNv=QN!Yjy28WEyofJ| z=phpOj0A>;S=%(31Y0&BH(Ee;ZXN*?lZjhQRQ)s6&1BYWs;WW@PmcrPOOHY|CB2G@ z`E1M@|FBsD^-u8ac!4Gn^A=N3`_jWmrxTP#<#HDTY2Be|afLS2%}A2j0%|Zp&zuY> zJ+FI>@uHg3;Yk)~`VS-%Mh}Eezx+TlWb{Dj^~(<=b4Cw@Zom9MGHUcd==aMHB-2I@ zgpR-bKr(RjK)8f@4`?#Mn6(VaIV8$p{s1}!$Mu31-m(aM=zw7qTL_N(*`j;4n>Ger z+d?;297FBZZh|<5+N<5Ha17}xCJUt4n+(_xi!Cw)c{1@NmRsq>iO-BD_ZABoKSje# zDpoWY^xO%9V1mdRo-FM{3G~`>Et8`)1H=al+P0(CyRIdQ<2~@mX+Bdwr9GPgbC*P3I{mAL<>1RxMgw-ij@H$82rpM2ZRmOFu0`*iyhGlbb3{ytNU)6alD} zdU*#LO5zGEtd_(VE~xujkkIrTMjYlNlcv>k?hy5)-Ml9~)TCK?r_O4ujH66zD0v%e zm{PSgkP=J|Q%)^u+;kk{la%a1sqJ?p67*K_Y@laxDt7vz+|i$Z++;0OKjUBD zveVW6ssXDNt5$Iu7otST*%dlkhZFYT8R4vDr+wTA)pGK#wT{-hYJDNN`{O;F(Xw+= zY{F@gVk@dKd1|c%xq(cw>)&!eN?%K)jkNo;8&A(_6;NV!%?|h7zW@(DgV^tW9`IrI zqehRj5+^z2{qB$jcYc|Q_YG3topj}H9q)xQgy49(qnxHLpzXKP#-*nl( zZ;32QSK%Fc}=8=oDX+*bcRU`6><0XJqNAn7=R^oR%DgL5ESi$j2ceFjkzpq*%J z!R?P07Op1&+1UZc82Yc7uMAN)FtqyDC96zdZEI&8VfR!=zQSS>u7A*#2$YEn=gB$g}o9li5 z2Z56M$-jKlDc99tfqh`Hk0SZu$L=}>q?*HU{B{xv3LLQr>> z=v*ilZdp|M$c34bw0YOe#dL=WHxM|Cq+hi+|RMg zm2%4c2aphG!2iys6TKQK!6gQw-N+hMSb1@SpUiEMT;rNIhakJzUR@VbIR&B!=k%ob zgzoA zE^AD&cUin8wu-5T?V`K}fK#F`ZDCG>ONOKR!q)LfJvfqU{3DHu9}A-zdsOgFdRyL` zygUT?M=UKtwVm)YM;RG92e_U5PQWG)e@syLxxY zRN?&r@AY@N2rpz>*(fC!hKzQ^$odK3b=Bm+2UU}MuV`7v6}Zr1$XGao)V7EvcD!uz z2lGsf9)0Ba zKgn{W|_|RooT@r}t&OR(owuK04@R+-X8p z`N5R_qaaU~N_o!w4Bq55rAmeD z_7L#GDJh%`h%L=rm!T|=4u6gwpZ%y94PS`{0+0k)_q8JfcQIe!skiWD zRVx$|8rp%u3*<1%*^il<@%?n;`J8-0+EQJ`hOE+|iQ*a!l3>YCG>dUp%3zw@*IK(-L-zXW5f38qcpide1{i zh~34X*k4uz}CW>x2eyhV?V{`n@*%Lh_OgdM#wr0 zgRDh2m9h>Kz&~u?J(i;w9nsxe^c=5j=oM@r>9OthRBF(42MUU($>M~AO;0Yrm4=F$ zDpQWFIm>8IM@=DfGWI8f@{QF^e|R{ zlm7M82GdAIt(hIbg^{cUc+j3%At1lsl6~@LW$a{s_dOgQt#{=}ixZAA$vPh9s*wlQ)g5{*>-TE5rz!ubeusv>c5T`PuJTm);RQ zAK`22`CIxuKbCb}KS)5|Cp~dqA94Atz8`ZwfKuP1d(ri&?(36X*H7&3`gC;tEnU|f z_}-f}2e`D;{%F_e2fMG2bYD3JrkN#*-|{RUi>_!tyLRx>@-&~5&*#)41=q6rBe~oZ zCPE>_Y5c;V4mIpPP{=}}saL|5hl(@s$ z6|*0>M?w!j(a(O$UkX8$(69(!KBe0*-K`j9y77@*!h`=-vvM+KTtgkwOH@lJXjxjeei7x=FKlb^g%85xP~}8y z_>F{G+KDs!5t$w@rh`?wq;8_k!;`dsg?Ho%!G}agYyy@`9JLZub z_2`Y?#B2r+)f}TC7i+ApXid>TMsEbDpTalTyzq@Tu?7}lZZIyVLyk_LRCB|JtSK{C z{?(_SfRRcS#)!aEA{jjN8OVF?@L2A<@lL<-!Cw#&{P(I>1L(Z*EUW+YE&yJCUVj1q zM_q|pSts4X7Dk`Hc+&zvuJ);ItVkX!0<%c-_D2k}P^i8?$X6dz&PBXY zM%At2MQP~8^3V$=yD;?0+Xg;2sx8NGqzy-QP-~XK!&zK}cnD$lPm7FWjnWg}2ms6a z6K{OIg_8IL425&uflgK*1~$L*4!+ChVHU!)wS*F?JH?}Kkw1YGX4eG#==#sa&qAp!1PcfalAzUJ5Fd$9M^UXh052jp3n9%T#~Ws~ z3NfF`yCP2=UU+UyD#T@}4`u-j7q207bPN6}PNVs^ymEpeu<<8=O9w{DP8D!ar^3O6#5}s4CmF$8hqDS%XaSWtBcf^cuR=yD zcP!05&URnoQ=iZK8BolB&^!&MG2Gu#Seorz^4=%L!JN<$|Ljk}V3z0$US`nMC?|vi zORd}sH`lao#*Hc0F|lL&yR#r5gI5dxPhB-1UwivEGI4z2m;x{53JVV713DiPbQS@J zOy&6Blyb@sMXmwB2Q|_c(px*>k(c{B?_3aLZ_A5o1bg@E`qo8X$3PJG2sZ5YCkCfGUTv!YB(fg&T(5;_xg zOoNsZp9xBeHok_u|Fbk|w$J^e+ljBJbD=~clZMR<6H176gTD<4mcS@+k=B=2nV zC}N4~%eGx0jWSvb#l5vHj4!kIt067Bz_!r!-<^^E?>!)?h@Iv#M$PU4$%L^4BtR)3 z@!=Cf0!T}R@7!7oq{+L-uH@7j3{XTPSKLgq&hf) zu%QrYVfV{M{oiW%^GQ11v(Ucc$t`p80Prz+*MR^be^a=q7%u>nFDiDnxR$7(?6W_$ zYy+YRPRQJ>hVTo*&1iSCkNq|nEmaIxRh;$7u0x&mIkEeFdaVjmXf&J+MP6^IWtylg zkNZpRF$<4zbDW*e`ixRp3@CY(dUM;u#FE<%U2}S(+9UzuO!ERjY*lQUj;?*y=XyHp z(^aKb&07)sg?UpLSM%nhnYUMsa{!y>SqB)H6cm>-GEPd*P)mI71)K_t#U_$!$W>4k zHc;nb76}2i3%ypugQ61XEL8#>8Lhps3f*5?IvXvdD1l=#+!2pzDR`(1^f2Y*6A?ME z1}Ky1L=2S4ztkDrvJATsgf0Y1I=V^28aAQxDRMv&bTXFRvk=9*EXNIZ8+ASx2k#q~ zibhiv?nU!gPJ>GdF<7+=K`9nObKc>;ktm&D zqPYd=(D4iU5WjHn0j9*gML~Zyej#?SK>nA6iHx)QvHLJZCww{e-TE@f>O#Ms@UO=s zUfa5Ulu=P0M4LOs>_iHE7hLk}EIHs1p?I(5I7O|NUqu-WQYyo~m5FWNix!FPy*$It zT)tO)r}=#^SAavw_u~p(6PBnffBRAn@WHkFlL{lV`|b4*cxnypope#m2^&m;Qd zbIM8uM*?^iwX{*&m%MzR$?a(CD}F7o&kAbXySrP98P5ck1bJ40NRS|pJE8|EfG99Y zkj6^@J%K3zDUf1+E`sLGcL17g&(VKYfT9&(7#ZK1+|@CW(!fk!*6bl`$B6 zV!g#<1X@E+SnfE+5MJtQ`(l%hI70lZKlK~;_{0wIZ8W>{bwaGZcC+;0F>R5Gma369 z+RpCME8=^!ynDI1@?(E;*Mb*ai@NBzGvD0=7hub_c=hrsG@wJdO0$`;5L$@7t2CE+NA4? zUN5{UXVO|7R2rs;SkyiHB_U5$bTlloZ1Gl_D19%`afiIc_I)yxOU5blI?Lz@3`?!d&k7n&c=D*`q|`n^UEXHvWpO~7YGRa^#cMy zilaQ?ILhPCdK@KaHsUCkAAC-I?2QqM+6ABgbcx{O5u`ZNKE$gp34A<)%N9N#eG-?%O8WYXO9UT} z;If6!r~c|p@cGM21Rsy!vW3s-yU)a*|MMk+k4JFX!sn6KlPkEAzMi~9@bL&PU-+C+ z|M{y+1s{#zvW3r+Po0VX{PiV*k4JFX!snj9JrjJsc!}WS5nQ(LX;a;H*%wb;BKUX& zmo0oAI3xf0n@a>Ak08P4PcJw7ouKTgJ8>#2%eScSxr?tV%eD)d{`TU4b=?IfMUwvL z;d}#`4<5|*F7}jPhK`R1&S-di>Ed8@!3m@uK|-uAMFQxs@qRs)Utko#K4&LIR>}2D z+J1QH@t&R{chG)I5&#@L#_dI9*V!ZlCI0|L zGQ6@p^?-5+`AIH54O9O>pJh$bzJd?;=5nId${{H0gYx$uWi0ll`8SW~PHIQ)-Fw^i z5qvV)p%I!SLP162U9=Nzh&cu6jo*d!R=HUC3Y+u%o|9%WrE>k_m zyTgZPzoblHg|3w4x;^HGf=Ftxck{a(ZXCnpl5l03k|xgwH4w^Z)6m)8=a(we+mHYMLc~nc@cLEN==M83Kl)M zr;1TD#*!rv0A7B~l>&D3xZu!4$TbyKdZ)NeKrHLW^2R+GX@^UJk$gZdxd0u2n<)^Y0ecThUb zFkn_U)E{AIjv@@ZC;+TNSNZ5pWpRpUj#{fgdj&%xaH-y#%2{NVO6|t8_1{WQVzzz@i@x?8gjAtrkC6 zjvDHPy#}!YC-JXel}Txh>FTH66!t5yYofqQx17Je77NB;#KlBx?APidjrAjc#*Tt& z#OaCh6v?ho0+_~YyG%x6z~Y`!eDtrBHf{=RA|1wxb?0R!L`C9RCbab!9PXDhSAIh7+ov>8*?Q(Xw#zlr_JXp#&SBwR_CbmhDWOD z)k1PySdX1PMD9((#U0}pktNQLYheIY5P-|37zDt2+yx6&F-%FvPW}=Rvx259!dQ`h z9whL0&}N05S2B2?Aexd1J}02DaTDIy<`yA~LB(6X&p3nRdlD+eB-0V7VJ z2c31CuQqnM))E60cA4mR`6DtI`A>nM>oLjpx)!;(k^U5=ps*AOJ_#+jSrW*P4*)@U z5ZzO^7CqT=E<|eUM;7#^O*aery|=U19o2&3%4?ffzLT}(KChK@9VK*Zj2;Y+1RM|* z4k8x7QX%ZcB%8>I!weXk7Bi*3IgyOW9!k3fC`Zd;GBS=(>xFLSbT!^Fl~aMJGR|a=kV>5KG}qRqf{6 zvK2mORfhuAwr`X>$Liw|GV`pHqM|DFB z(bwp1rh+iLE4aYqJl)35lUd1g%#oP9K=jJE323$Ih?F6$rB z(BT~m9yQ*~#!{gz9-t(~pfEC)+a(5tn6==c`(1jF!)EAynV?{8pfY+UkQ`#5DU12x zQh%jXHErJ4S9mz@>d{a7F4HMc`#+@&E|f$t7>+|=%R%PYvMxra4 z*f#Z%_FY^43;0u+?p-YNawq9t?H69Pcy0NCR{1_-340fH3M{x0uu9JdbPs`n!1I4l zu9-{E8qd%!ZZs}!F2zJ_yfq!sgb#BW3xu=x(2r+_-CGsb<{2wvx+C1?tH03@K40&S zi<;W0BBBV!V5@9>vYk*gMr133b1nfkMk2_lQ!#BujFCto4-qM;OCvfK9YwMU6xTB9 zhk-=3XPQns%U&bE6h+>Ogf>Q0)OnIn8qEQ48*K>(+M;yIISaKyBT?bnuTp*3 zhz=Rx6Rtf%r~JP9L*LaySxFkCs3n{Y%#R)Qhd!c*c5)Iu$D7w5T21Y#l(el{X53NB zthSY-Rb-3DA)-htV-O*QMNNnqirA7_F-l0+M0=dn@#F$wod8T5nh|oD4F13s#hTFBgrW$Okv_H@ z)~Pn)g|E~eh|9{TEV7T^fu8pNy+F(#!4V^Vc^7qEE88~^(*LxuX$Sq!m^SV3z;l<= zPd;fm{qVwCx*o^;Fe_uao@^#{U5`gLtm~1NJ)!IQxxcRK`FGd#{QH`^9*HLaa*}nu zH?5B^H4Yr}E zL+oK8Pc8m1xmEk$H@%Pr6S{-!$5!~^HP`%TogJ~d|IaP9-AJcCI??fphE(h4Gd_4YK@&#yrd1s?c|3};!fgA4tix5ZGujB$5(vV2UT@Xj4Ew= z0Y$giF6QsQ862^wf?Y&B)9fN}MwXl?7x#tiBF1Pvh8-?zBb98Uc%qX;+>ZFs4KUSe zmqZ5Y1~(|r+4OYV4C&AI{8KkDqA@Z(DGeWzR2ggdf883y`LQ=tZIYvaAb?!2*+QF| z?5tj-1-raW`q68s#bc6-*=&XE0{!>EfOijXmHT80`IIca4LJ^{YOe1*y=vNv zYHHd@TenSgZEPboW@-}VZ=KxT5wcl3A(Xn@EtHdciLi-?Mr|VxH)cW;uQ={r>HWS} zs&dmdu^BgoQuY5L@fOk$Bh_jv9;kMQHeXO%!!GC5=b-jcs%f>Y>I5=((iPpyzyifn zEAd>rXTc}9y&rfH6T5I(z1Nf3 z`s%GyTK{fB7>`N~K|!|5S;GjW5FW^+?T<8Ch%yr|fa0-z!2=EmeaW@EMGVLXjDRqv-6;d3GTARXI7Vc{ks zr#ZmBImTG-;}qA-_x&S`G#1vFpGJ$bmH(#Vc+3L=k@yL0*>3J|4h`n-<@7oJt&`uP z2QSbip0e05(c16mY8_bC;*nJGLVUT)zPNSq)_C#t@gm5`Q~;P~%?7Fnv*)nT%KOq_ zznJb@d}+$Grzd0Dg{Q`}j{>EJo;x0=-OGQf?#sn3PLIFNg0dLE=!JSj7_n7WTn^_i zlwhQEaGVZCZ%)#|juWASm$M2+{<`M&e_dWVuFs!ZE*_w3)vG$HZ{u^S3s^8089*-FYS!ZVn zn&E0hjDA+Oa)crcx66IDoK?vgQubTd=qu}hgCcMnRiJPjh~%wVDW>tPn@#{oABkuZ zlSlp{*=)ovV~nF~o;AQdwWtCG7>IUQ!?5(qQwPV8_!9-GKMSx!RQSeVI%&&h5)mw$ z4<%{3De{;w4!U~Q#zk$64awLltHj^V7@1lyO2-YvO}TsMnjb~bQuLXl*e>5V1?>q` zzAlYV*P^`aM+G!-uwkOw(ZPj#lbY!}7?;LG@cr%n2PG~h$*VT=%MCEJxgMgH`Kae@HnA2|_Nf66u(8xTr7(#k(^V@>l2dSwh8M_ZlhB{;Dj z4!``wdw6JUJJ+lNv@XV7$`3R$%%WJOhJJ1byqC8(UJ@brnTj>);M?U2_WlRdc3 zm|%%2VbpL`X=I!hvDv}BdbDla(1htBR!dFx5<0cDgdH}_F=1!wY}WO1G}{G^SI~B| zPnB0x*-#T(d*x34yQ)8>b7`k)-zPHZ4{6eUJAJ0&MFx>|D53+old^Wg>O#Armt z`UVtd>k~fzP65ZQOq6Zf62DfgibVZuZrLcau5Gl}kbRrpQL^2qbpuEikZ=SBWpz32 zB|oB+p~1be{$0AiiY^$->)5#H^Wa%U^X!x@IL7cREHcDT?h?vz&)dGD%tiCyG5;$I z(^pKJ+#GIFCMzSxcZIM6i|&=tzp$*Hl=4nz+7JAw4g*Uz6 zo1836pIY`bu3F0zh3NgSa_$WG^Hp`k^8n-=QOR`?ZiN6pZ`J{ z!Nlqw4#J{T>B{&$maZJU)zWxyG$?fkZZr2@LXPhy{idpX8DClBb)99%>!c)ggVGlO z>A#nhfV&CM-)Ku!(MkiP3;&qU-z|;7k3XAtT|!4{#X6f{pkKp4R60j5iu+Lg+>{V| z5gtTr+X~#Hv%*Bpwsf1^4OHeXJ6!x8-#X!>AkX-1q_ zHN70PGp&v67&HnCqP3-j$eD@(EwC8mp*I3P6yISihWq4!PNK4;)dI1yo^v;#mHMok zwN<|JoBT!IB$q9gxBB!fz5(zKsPARCC)r#1(jBtXF0S`zR(Nv1R6s(7Rky+Fmx84V}06-_^Av*sXN&vRm4 z%~92rD7n=GdJkPx2gnAkV1xt6q_vdjNo}O<`cg~8)7HLBU;6oHl(eBehsjV2>JzS# z%7lqr%s=!d9@56HBBb`~ z1`j6HTieD0JEMRDl#SG9P!jlwyU zpHrrE(wdbg;xablzkQX)Ck>9BfR&TlZommfrM)&!=V2msXhdpvbuWo!nADLsTXLJydxTh&mUqD$m5x%Bn<=P~xgovLJ<;%w}B}{E$Yv`KvjM>tldsW9ey_o}|)djEY3~SX~`(vr&FHC}? zhenKzG@`7U%DWyQ4C}p^bMI!_;;!cDt?GJ=!HfeQ=HC3kN64)`v!W`M*-u-{^ z?#K%l0y%@4Q_1w+w796ZN$bO!w*_)=o*Ie41{(x#z~$&T@oc6@Rn zVU2GfL#fNZSdq7IE4{q)o?-XI(Cf#U_kJAobYS>h;c5Jc^EI$F)s+15C~A%?XyRg; z7W0en@wz)cTm<$Tts;mQ-Vq(7aW>=bajo@ybWCYK!PP8NOQ?5ZMIux@!hK3|kH9*$ z^ONSnI+n%1R_DaeJD#j_V$%thv1ogplWJ6k61KriWZ9!mlIFt0WZ2e3ZCAA*gaJOU z^P4zd?WWPrk!#S~x~6&XNc(yI$b))BiipzH%~t^E(N+WOLC>E$rJG>9uaa6f#(3k- zY^{m<)j6}AQEW|4&D1dF_Cy zT|WGSH2E;qQslkYp2U{p08gIwHVqcenN2MD_Ti-klz1N7KHL@`n|8VrXT;KUy01L? zO-ev&OFlez-_m@TplvL|i5`4|KM1#SLtvE}!8!00grw%|(l)Rm2>=N7zy#5rpdY`6 zXfZ2yk%uqd0wduH-@z=d$Ic=Y2Fzk>{Q^kY{uSG3^U@oTtC~hh^(5O}K=njIJh^2o zNski~OxZM5V`C4rO%+lA&!%V`#HkS4){re!a9d~xN7L2sK?T5C{H$SnW-k?(8~doK z8XpupcA6Sj?rzd>C_*sB&=E;*V=QUI;RyNb>MT^#=u~jx?0f6Z&tlDZpE2j>?MW5q z4zV16r^!TBys^fh+T}K^3tEb-$7(4i2-$=y^%bY6IGX8SC88;wxtIZ#})K;_2rM2CW2s-s$%GbMs=2tU@t| z{L``%Z5u2s)Gr>hi}MSE`o+)K#kqyX>wjw(`wMgRC;!ea_7>3ZM;(3EE_M+gwTqv# zixMNXi=VfPZNy3K;uq{P=SmZ%#03wi3xg~ z?i!3?YDuO4GS^XgOqn+;O1W=T44v-VA{L|H1@tvb#IVwqWy=g=K^F857ri>;wv+xa zX)UE{B7-k#p|plQZU2UIdBgQ9 zwnVw~7cGwcHg333KHkQ_{U2Gm^Ck<9K^p8T7WUkE5J}52Uf9P_58$9aJlwXom|Nkf z^@Xy~0hC~GZV$a5_}>-{Xn`6=ew%H8d+dxZUz!^fgJMoXN5*s=c@JyA=4KYRqKmT2 z-qUoaqK&w!?4%q?h z*ErWME6)?^F*KyJhxfLgJYN_H~sZR-7C&-QZrRdPKRq#kPtYON8 z@VO+Tx0QAmILmfvF56uI7F5eRE9QiMe)7Rf17_Yz)9dL%F=fj^eXW+JBh?b;uNO9U zF?&LnofDwszQWs)+&=OYX_-u|LA;xpv)!6XerH@qT?+^ zR!)(EE$VJNG0~hAa9X}{IFKFLdxS(|r(wK8`KVVPbiL3$2!5VfLTaQ%Y&Y-3s`-5N zn)xW1%(-T{J(}hFsxtZg!K+5Rs4A0nhVmjK$}#SBYM9UU(EebQZb=^nNkaJDlZZVvq;ZCUStZ1m|~3=Ij0=wMR-^Q zf93l)*}TYbWIMy@yog}1abDDi7g?y7@gk}^3;%%^&7BfnB*A$cUUbe%{?)*XB$f6d z>-$T1wIuI1z>>s|elR&lbmcP5Snrj?Iq{=ZBnF2vMp*PKwiJf$Y$*aT$(H8Cmc*cs z&z9&Uu%&bwTN=#R5(e-I-Dt*^PLhf=V@oHbB5jN_?J=k=SrmkC z+4?2h)|s}n*`3>?MO#`}$-h2gOX+5`B~09+t7+O2Bz8P)DFQHKOEb0vvCP=gmJCXd zBDVC6N181e0H>BM-PZ3$J9qM*Pl0twyIxtlGc2ZCwsfzjFTHbV(6DhADIrw96E8;F zIi~IZrNuwZ>tvM>O$EulU+oZ{P+ZrZk z!_ibT&o;L&Z^g{B?If9;H?W^VZ}{dGImEw87erT^S6mE$H8=!`#9KG>EDYXW;}HAL zW)5+8T=c;UW*j13t1*bDi$Un0<~?H);ogH!s~)PDMY!@%WEfAvIZ`nUvrA6%QOy{} z$Vc^PXBfn6J~Uz&**>MEU>n8>w;{W5a8(h!E7I!A-AOzNezss54mROb89&im6$sGH z!mWnVg88bLnKRU5wE^!rUg?K9ql!OQEMmXMbN$2aoJQCOULxfNePg)r z`*`vddCWgkqNp2Qb^Q3u{hUf1FXX>wnJ{wG>)OoYeS#kE6Hq_a_ISJcu_cf9$x=VG zi#m>%iPikAz)f)G%f*Caegp0$V zIKgtBfQ36%D578V6d!SX6~K1PGuLpYw70dwRE}p=m`Bwe3sYIoH9UWO*RY3b`uWeJ zC>1XbM1+chHfj+n5Jgz8S|_UUg?K08)Wkb(-{`PSEtV3(fD1Kuv)gKsUjE&VieqU* zNQVQ3nXs@3s5^;q;TG}&KnR^-We)P+5E&AiLox^Q5q>$7Ry-#lCQk8DWDqki2xg&k+z-~Omr_p^{&%c@jf zGj}E@ zQsh-Wlf-m;G@ z_}o%4^E;IA!3wW3FV;?x8(ZVQ?d64Kd0C_GK|r8YcWPVeQYWM?#nicBx3;16@8mwg zll;4A~ZcC0d- z$O>MwvV^QQwK5h#-D+1EPGlcihEt;Cf}v*w50hGYLE`BJZR$i>j+0Gzn;fS^=>?=s zr(`)L`{2VE+Pa5_$zGM>Oo*sgMx$jJP*khv>;Vi?oiu=u`WDeycDg z=#)2vA|ccfDX1~03zsc=wUB^5+h_pC;Wm2YOyM@b@@U{TGqO4L zLaNSf9wlVM&i3r)HX6WjxQ!k;Q@9PVJQ}#ojBHLXw^@U1{@&|SYbW&siV2}qU*jm? zGix99PJ$7Q*|4YZN`z^VD2%qc9yf2=oun2lJ9f*WBY|O zL)8lf(6m+howEwvRDqm|?&@*_+fQ$Wf5vVHjECFx$V4#j&lYL8`_KVh*edpEV;b^5 zmvziyaJE7?am2sfQ5{KrfuW?x7#on$hdP!$N{#XjZ+!%64xFxy)sgennGQ5jAwh+$8WT8$W> zP6lTnNDpPn{DCsHbDR^aMcS4@zIAb{M?wSvCDeKbeO(clmu=y8$@OCoU|Qu`wl6;_ zfgxj(6#x`Qe%8vcB`VaCPzj6Bkc9A#?oy@*6RQ&qsxa`~G#g*Zlxl8Ck z<>s-$`5{Xx2!3g@KbHET>T6k0Hj1XNT)gwrOK!T+Op;z4o_dqqZ1348v(@5op6*wc zdZczJh;@+dPO-Mh2$}IRBPndC!~UL7-c}xikOfgvFztulRyu5eE%OjMD zj@Zry7XeMV`eLR|P(61!{p6EuvR2BQ{e&Lqmx`tjQ~$d)_z`8)1cD;Kinc*c*sr%0B% zOY;Bcw{>suZ}?T-zGer!mEUzMPhLP>%JrIiyEhjgzGuw_w*c{5y^E(hQjV?Bg^ksa z45_s^h(hH`k_sn-r*G-?fP*V%G9ufxociWyYoqeaKE)N&L6cmF-u%fECNfB6OJ z=ssoJGp)vx1C7n$*Ve!Xoic}?*vK5dtucoOzkUj+?#+!ZUVkdOINa#s$f@Y!EsZWd zcq+QM!@IDly?@OPG_{}F$kg8H&Al>7GI5kIt=Zy~^$DSK+Cwq4SY%bZgG1VJ2ApB* z1(3@GF31rEZ_sMN@;p!3@Xvf`Bm>8e^SETu6*jWVOX;CHZJkm1Ct%DRNo|$01<|1ue2gdv=Z+3sWq;`Z88Y}-5jmWla!m1k2Q)No6l zncu2oItziQ+(j!JtdZk(bm3``mW2y!8!Cm0VOU^c(c)wWZ%6{qD-t*=a2q*@wZ2wu zpKDd^)VfWT9)M_21;iRjL38({fB#85m4IUBcVzkNjWmlyHQ#8iXgw}%+vym3-NjYy zb;N4@^;UR2p1GbvDn3XD!&-x01q-qpu}dewriX^AKrAJ{f{pL>#yb%<9EE}n=p42< zxQ#-`s4@-7$2j<0JLw)kW6Hc8Du#h#BPf9hOir{xQ%Umg%70Q4WSN#loS{(g*eI~8 z;o;U31<_bTrQ*~U5fD?oD5a2_UO73ERTo{aBCAd&avWEw+7Jv*%I@BJ6&yga z#nm45fl4mzNn=(aF;;*NR{Ei{3x-KCPGccCPiY87i=nV{27;8Pp@)X1EibIpdK-}^ z{?+X2GQCdgP86+p7k=$41L6pKrkOq+ox{|VTT`5+I0U6c4j7_rrGQB*KFW_0y_3O% zD^@!^S!tgqOlEI+?TpNX!4oDkL)@dC%(RM63Yi_5k(n*j6DBi5++&u^_PXY}`VHTe zz|wU>qr`Y)*K5}oR;WgAaQov`y;cGmi4{Ua= z!7rZf9)m*sx^~h#5IhB=voC=CLfc=;0`T8!fC`dw6!?J^Pi}FTAUgsSO-bdBiRA7g z@-f{v?4h7)c-0Aa@mJ9yDoIap+8Ea;xu-}`l|Dc*5YD8HqC)b`6a!Rc3|3K5kWEDA z(Q@9%5dD&x?Yyr?tVX#hHdYE)Y8Nu8#JDLSTR)WO1kpJxQFLSz!k<3fWxK-#(}Ja- zVG=4|^H~l>%wP692q=dm4<;qvY7bGAfY44v;ZvjR3hLZMVJ_vnWqO~&?6|&QItNFO z3z~lhR2raf%zk(S>4WaAaXnL9oY?cOZ6WR*af1yoWp_6FZrX*X%|MXhmTL9%o-6Yrj9P{|IdobPa z#oA)TRThPhB#y(3io&*oeSwzsfR=qJJ;T0hy)T!^V4mwLZ{50l@O#>I4ju)&PUa(Q zFXu+v%Xu+G%$Hg))%J3M{bIEbsBJG7;`Xw7OEgcrJud_tx3xnIqrSahVPPI<`;U|- z2fim>pj)(5PD;^gS%|7D&&tZGRZ6{ap5X_!T0N|ts=C$l^Bdo(21#+-X_pkIug96B zSYJ}ya`sD#J2oyU{LwQ`QvBAd5e{YQlHzS=jifNJXOco@q>AT1x+TTY(=I7aUyn0M zvA(4Eo*Z*$_nzX&#wCS6dd5kLV0m;&ao1TRDGcnHq<9QTiesl;Qk=dXXOiMkFDZUY zruU6mpZw7=NwERb$!-}5znZuys~0O2@vxnFth!&FVez?J`@BC)n51U}0yfyqi|O<#cVLhuLZ3me0~ zlIgWvb?b>Wf;lO zYJmSWC_*}3reO^``N99fr{g1_)XaSm%>hS*Z2B3t-AjuXUL~XhiiY?&!&>jUC5tib zUV5~}ZES$~Er)1V!KMk}5&_@C)G=-q_i)0ZYfob8%`t!4FB`K8Yt z^msgO$=h7T<6%h#$(&B7=XCm>6YtNagVSIpV9|}oWjMJFK61W00Z@`Cx#z$9 z9AG98%c#mU0Op^zw9G(wdEXZR$RY|q{c_NGL5bkQ{pt)Ja zJG$P+9fFJJO4zqncd~bdAlZ-np@6lwWzD4lR#o|`Z|Q32pG!wu=0MVDV6-|;eHWkR zFTfR*j&_kL10*;`Me@df?eb9)W;TDpnt#d9#iUdWe%Cc&n z)E*ahaAfEq-75&Sy@aT*j3z3+K$n1w-MK9x#nX7b;Sq$JPtM`=izdC;S#oX*ntL_e_K$X z9jG^aH(X0A@iX`zEo|23EHSrEHF1V%;9~s_-aMDiH)K>h$nSPZWk+0iZ=w%LemV(E z9`E6Ht|Y7i2`%FQL^Lr6lIaWF!o7ArY}Oi_$UM1meIo(;_^RleG?i`+)8)Dz;Q^n36U>*dx_5)61JzPaxV6v zJ@rD^pTJ{^2XeE{tKtHadb#BUgsxuVU5Ugy2IF@WJ|18M7#o=4f_7?Q>V!(-@3VMb z@QDpuz{dd<0EhE9jC|flJ|9M2f3Q6SE`!Hv8+UEwlAgn!jU4avHqM#nq+2eAk$3S( zQGf$cB|mYy*k&Wv$b|tLIYn1(#F>))$Q6IUG<&5RzOdqblM_9Puk!W;K@WSQ;t>8N}0xjl$Gte!w6&a#yNFyVA#s z&fq1r7z-c|^UgO#gw%f+xldU#P)#g>JF8r3caDmhHNaLycgQF)L_FQN^jW4`5lqu{Jnrqc{8iNxW? zJN?0nD3we*JGjWh=W|hoqzzfn9qVvSD&fwEO6Gt1Cy&ToaLL#cf=SD1f$OCf zl;Q=Fd>L7Px~D=uMkZR0Vb13UKO7>Pg>BZb5$hGAQKQmA1GR6c^$Y&(LZRDYo;5CR z3mse;Jg|_=O-g#v^i@k4c$Ku`(W`Xjx#f2|F3i*2`u%J#-o&^43>n zVS^SWqfj6ZmpS-?)HYU~vMAY6f#&jPvX}oaTZ9#9iNb8`Loqf8^77qZ{nS@}NjX>4 zIYu~?t8yj^z;-pZcG*QIRS*af!E?s2S?59Q0`w2~rH?`!E{eJK@BG?7_eki%2Urzt16Z#30`HZEHPf*npB0Wyb6C?zrR=)jU8LOXY+Y%I>0G9gZZDU)j9-={L=P8nHpBsAmhHcNrK z12o*7U5dy+-@PHB+*y0%@PXl9&$_H6794r+;5OMwc|HYBi7f0&;>Gs0059?KLnvH_ zEC@rl(CuO-XvR0~K2axV9CO;D5WzEy{ybBM%!=eKS}P_$^paXpV>F?jc~=}61#z`) zK-g^LdUO5Vet)%jNa}u#24`*;o=q*&+z& z?_I?12ttIRkP?J>1BL1T)y8_|&OvSp0r#`~Pt8a9s0D^TI6;zE?gyEttU}x^nZa?6v>D+zu<3Sg`Z` zjHB2P3F9DG7AbDzCsJZPLM;5`1F$>DLN-XypewY_ZxJDvM`Ljv7TM`Xr3egg1L*xm z(}Lc!&8y}#=RzsF59lNrJeacl;#BErV2%7i-{B$J-5TKr{$spM^aT=q^UVg3Oij>k zn?L#rstj|g&3G!d&TU4_T=)(OO*6)MQ?8S?!5SKwWFXomOzmTEN51OO}7jH~#cKt(TFzDDo#^INHQqE$9L~JV_)a=9EObQ`w1aiQPQ# z!`w{sUkS!9Q}5Hj%vePgKQpp1jd5CYq6b-FHq7h{hfsA~@gkxTze7gT-iG;|Z7z&8 zZkXRWF9!;|ZIISqY?0+D6~h@Ud>3$z%kn-W5n~HQ>qYeJ%R9*{dn?1=S|a znX8kFN$g-mm)Q@tT0hj%bfj8OFcR2ueLeZ(jU`plPV7lJ(`F_!OF8=|Uqs;(D7bsA z=_b$EhHA;WK;lYwU20Nm%AE1aSxZ)KfB-hbN3L*d2L&85Zn5sSS&VQ)dY#Mrq9*4#)9`OSd?%_a)QaZpu9wRSQ{8NuHIl1Im#N1>s=BgmkX3nN6jaghPhD{Ch80 zMN%;=a*1J6`KtNs`AsU#f`mdV|7)!g^D(;l&Xot zOjmktYjC56VBjD-sx)m$BkGYTS-b3C>n>&4cElX^?=|tmS1ClyhAyI(x@@6O!9mZh z{G);sDbdRB_ixpmk5zX*u5W{{4w5|bQH+I2(DNLmp;=C$W^vWFFrd-d{zQx_gR|By z0Kh;BfpJ`cHd3rRu6q@2sKB-{CM~5TXHs zu4lGmbx!G)S_K6=y!=bbxu>KybUP1~C-N=e5h!ncJOUXw@;4pi0WKVQyjGlc1;yMR zBs}chfM}ODtR9uM8wE4Fj%*LlDo@IS3sqW9DKAd)%tfOi^|~6>bQs5J4bK5&28pEn z$-TpK@d^y{@{V7HxU^3?r+ffQ)4BOuWd$APCIQ$PVqGksvUde`H_Quc&eHZWD1M*Y z7l56qHuOpTEDzbv2dWV)tPSm{v@c;ymTxJdmyuc@^S~mqqjN@#jt=n74K7=>ju4L! zO?&U+)lL{pnNiR%D=(6#u$TX~>aA$}muTv-HSwPN%!DkO)zMg&tdyPnt?%MVAcO;m ze~9quK5!`!uYFZaP53Gkf?sq4f=F1;(12`?NM3tm1TYi=z@~;QUQHmAnztDkis*RT zOe?X%1|#6vR{m?^Gi)oXxsHY&K*2JmnO2wHL_nBf!<%O!=QWXV$T*Qbo5=Yvk*?bd z=FvpP3Kv|gCX!Ah!Yk2}4Swg5WBTRXb!)Kwih*L&3L*ez#7y*!oa!8(>ME(G8J329 zzRvOc#_{L3%<;`twHC*h)sZ=>0EPgL%kiCU!QMrj73;_EHRt zkMVAAxyHMzmPQQ~fpPQf@fo)ZCFCza7>Cx7JjetZM!|5$kF#wwPjQe+(Gz<-6>J;G zn{3;5hEU5S+a~nDDL1lh!PsQm{S#r^*rJcmwuP9pmu(+uZ-j3X@->BT_qWWqADEvh z>oa9NGP{woE)F!)kY^e)?A)TtOtj84WH~UjJ>GAr?IgJ+-h! z2*XKxG%WYrLd<_9ze)f^)NdPo{c-1RT0Npb9?`7Y5W(`S(eTKTuaua*i{V~3#0?Ox zDt{&ppbR_|ZQN~&fRvwY$$S#Z?x}+HEoY>P)VEntaJyoG*fTIl?}6}CT1^0furdoj zRLv_(AzG^o^XMrufd|<5dt`!^IG_+l<>NA6E@lN9W&$l&)o%2QzKx5x%-9`~UzUZC z#eoI?Ev8o=82;NZF!f5hATQ%2@s7<8QdDgh-TW`jzhz?uFG_Gy`wU*_ZrMkKP6Xt6 zw2l>EtD}NIAA2_i;ZSLSi@;AcC-8=e`!@v_SM2dRLUhg0&AAM{2$(R{9{fRrcY-FP zsN-|be-if$!9GwX0nu)>W*nlaQ^PeqvRa`$)vEW%YLBYal=$KeT(d1gSf6V)nslyN zZ<4iHHR&M^qb5&?Yc~3EhF|Ze4!Uto1AT3-*=TNku#Ibab5ppc0rBYPnjYolvLO<= z@!6?tQ;Sc_bmVGAct*~u3@L>#7~2%5A7h#x@2LgMy~th&;d7>`HB2->V4A6zrh)@3 zMxn+udA?$rat6Uc+%+VonK;u-oM{S#$TV5{baT8e#3tx;#5CJ$GR<^?X$m*BQB_Pc z3@k7wLb!Zj#++{(yLkAmhza}#m zcq*Wvpb){u0}ZBW2;o|2I5N#b*Y$rZe}M;U4Q}m_ek$z=MMED5YNHI{EeKBY+qoj@ z8ls-zQ7g8fHwd+|xQX-`rh#^0ZpcScWNn^@EeboBOjE=1O-W=96Ruva@K0en;T1j< zI!D0R^PvIr_bM=zJNk{-NKkW%Odl>acq{X_5K5PCvv{eZ1q@EwHV(mPqnZw*MiBuT zfmuPW7$Xwl9XN1I^a7A%BKoWjpkL-;t%WfF^(?pmz)Uf$4q!mE;mKfdR0;QEvR`m3 z?{^%<0<8cmHh{%ptAfJ=*WAynEcKB{p@$Gffd$T+PDdB|<{wv3=OAV?0* z?%AAPNmJLEh9o@fDqTFOKm4h9cK_$FYj7Za!Ujh*Ph~QOkr`fsuXS8 zDHr+^TJ04SI*8QJ>I{x16utu0rNS5rXSQ2$u5ePntT_O!QYh)QrHAy2o~6l(LKFG| zf=0Ks9)(sxA-c1*alCG=Ki013PTex}X17jv>K2A%)W*oj&NKEx&%&^UkGFWS!jgPh zL9LsBRxsKd;#y%P*P!(!YB<30|-@1~$+KY>mJ^PXA8(6`BI#HN0t^ z+YH93^3H=M8eX)ia#Bp5A=iI4IGAYtF(A=83x)lH>TKv5bSY75=h$R+sNd*L3`ea* zZ(^@hQd}Z>a#KUAwylBa3G@4uv~c=U@Eg@K{%uG{EVLI_PbEm?4W^Zq%pY5gM5Ee! zp6l>)4dA7nom>$ARv^-90P({eN|Zx7P!$UYkXXLP?|k{%x`j@4Lo3m?HLOIWmCDnj6neST6cLKu^<%49?73@wrf zpjPxSAvyXaf=};-;BDg`z$UhhXJAP~RG)i@O|{h&AwWlu5a2(a0)eCgnGp=rWFZFUaUYB)JwT3j@$1Fnt4t)aVMB5&D2%$Txb}9QsnA1(GKE#IQ^) zLST$z(SQd^y;osUdk=uuY&L;+OtSr~fFI4}Bqqmzal{Ciz#Ye6LY@!FD@mje+58D6 zF&hXV0u-2J6RsY$6g0yXT!S|$z?ubytoH?G>)$AwX)?{nKB6e91QE|eY|NH)5mA>t zZW5&-sF_?>DNF{ljx#!PoySy)4)1E#^&wlD4G6}jl?7VsDn-4^T5lS>3o($OX*gb& z)))FJFIt!3l~I?KkT%Zvk;H{G_gUpi#!%j2M{5y?G+3otS_ZDzUd$>^uK+#LKe(%e z4vdSIN$V2>7P>6z`Ky^?y=wA_8Yo5kS(b-EFH_z&z~};Q;2Ezx4>tsiUisR0eg0l$ zg2b;9uKf}lA-sYWZ7k7BM-1){17h4ZAQO@&FedQEfHdZZNv;cnBE+UuAJlz`<79kb zbjrXcnm9Ql`(&bY0i)i;sn=MB??)J`7;@XDEsgq=J%>|=?6=WO0wMzQ3NQ!}j?^K> z*V2@U^@cf*ipUUJ1^FR--MGA(WSnKdL~K(`+rvp|UF522^WJRjX>XSukhd%DJb0rD zCXGtNWjmB5r^&Ai*(4Yju^gi6$yzFfdpp79kglp*(4g`?IflaGGaVa7xXSi2m)DRJ zO=;G4a$b9k3qUDLD=cAXmLo+-0+zmO6-mx(KgGJ>IkrErar6jDNHxU|`bXG5V5U#X zV@TfU!WY8@DGqv4@4;)IkUqu6McZJEcJwP6BZ=K}0}}&W|FJ=)Mwx9l46AWri&n{B zGMEbsWz|Fa>BHsZI1SYD-vp;(CqQMHNZWAFIiw_%W}}$NbYKaQ)=p3fz`N%%a{QSg zK&2vDifxj9#kccU_){>;-d4gfBuk0#06f8b+`*4wD9MRB&HtOQh4orm7R*vS24Xv3 zf3~lbE!9D?^e>?1ilvemqBY@q(30$U7q&%tCD@28b^0wMI96K4xyB<3br_{1@)0!0%psHSi5!xUJC2p>@JTPd@*bBrKE60RwKDj_9yZE4Ed3kK{h&(%$ zU4?aMMJGy|Xz!khfb66xeqK4iTfldPYQ^R4o*!??i4a=HKn zw(e?pCN1vr!Q0nKJQaoHmUvp!5>Lr*F-)Oll&aIFc+Q){MF>V-LG7^>BqWLXAqwSY>9-f~TW zAq^q6Qo2|HtfZ6>+j|8n^#D?*em;1G?3Rie+Do8xZG>}|Y_L$fh<2f3kZgR{N!WZq z+GUMk$? z3Bg1G{s8n#HNNh?2IH;M#R$!qPziFwTZp1U%gPx*VBMOW34xI9rjgUc=s#ek3kA() z7=7UHVvLps2HZ)F^CS(EmSYs)JZ{~703N_K?Mr|~PEW}}#eoWP=DSmT003~OT<#P2!}y?&%l zb>b>vIx=wqDil%o?n$Q4Yl@^EOt>O+qtg2Mp*;~#VqTS%B8i&;mI`OeOQmotlx?Tn z=h>Co#Itr^#wLhZMsZ7%0fPIVWbQFD16Gv7VV+qlVZoPbu_tv}wLYFnRD!B~kY$U; zV>M$GV9{B?+Gr2CS3m~-uYL0+RCPc`4Ci>!Hj_V?q-q7%E?h*-)*e#ps${_V^3;4W zqmyOws`)ld-kYB*pA~im3aikybU5GKDR7NIkH$67HdlVObu|e<^H)fYqK8$o1zOX~_iAB1x%t&@Y_vo}=tynsb!J4I@u!UVM*f+pVo44AhBk zMbNJAnlUBVN1aY<1ZqiGB4+qJ**2j@hNU&B5Ee;oa#@QZlWCyitDifuy{PY2kxMfuu`O1y4#^&;}Ph<+WgAkiiDKKH@;>Y zjSvfzaGlKx^roH|qb6h`7RZY#mU0cZLoATfpBbstNux?w!m^ueZWIR;np-N1vF6M? z6Ph!RwiO*qw9FWq1ur?kRRqw90&FI}(1ZE1Ll4SZ8z27$0EVGhsbY;EEMqyBa-da7 zV;=m|_5y1m-b;Om{DQ_%z3u5Rx`kd-WUGZ8$C#jG6cdy+VuBEJR2mc)oe~q&tzv?p4JW#B(oBkqG^Mo}$|II6 z#H>~*)o#kiXK5TM;LQO#fdWgRDY-7sc0ed{`ih?Al1Hd5G2LQ88v-hfN zSiN>*W(B1q?Z!gaD&=5ZSG%z~8t8FkV(1QD-;*)Y=-ufiEmKKJ(C}Q-#-)JpK6;A^ z^y(`L1ZUanX8adK)fEUT=hPJl3I3V_K|A2xp75Hm+S80=VU%$^kSby`Xb%K3)*ezZ zIcX1S8tuUkV%H=ZjG_02>JXZ17#X=nnb2|7L3QS?rZ=e$b4}Hu8VObOtha{hpdb-f zB4XV}#}C+95K6r^QE#s#N#MHL?xd!+2RY1dE50}>E3BHKFY0F8sQeu+kjndv^;#f> zVjO&_*G12W^@ipoE1JzQ8&z}0-9mGw#=w58s+P4JYAyLD+zQ#4>4zbN;cajb8nZ1( zw`Uj%YUVXjq6#)(y%(xN<}F~VRH!Wchs@a3stU0h4G4r`ONrfyzvj8!t&r5s?Mn=B zF$h)>3#gtT2nECA!34Vjb&7%Zoa!JkAv{AvBhIJWqRxo@jmgV-q=}ZIiwOFZan^}f| zTD-99)|X*yZWOvLlcr6=BfAVYvj#(!?j{$Yt?>=6K=_hH6Q{lcS!-eW1(7LPY0D3h zIkx=L=JNZMT0uez)wFj62Z^yi$xQQ3s~=dudSk6wc_VDm6c8R0k!Gpj;goT7i*%_6 zQ=k$jqVigP2lI7L<~=;}XrydPukdsM+3vogqDp)<|!@ket+zZnMVsshS`*(zum zRiQ0afv>0v*iYO=rdRY(WJhLefa6J3z>HwF21HMTIklxK*b}5aND~0Mk*c7#WN6@l zx}kx{@Y+MJPneKw7#bYL(0fBw2+cKA1+HO!|X57y=H)#dvr&7=`9?P(^J^s-86 zVAA=Ng$Y;c!WtnI+=@YwS{J8HDl7Ej(-z}(r@=T5^@nGyEZYChNLJR!c#xGW z3svTHY!6I^>6V`E}MtnF!RtcoZ%hTw6rXBsBl3a5mP0bYZN(U}`pF$6y9IN5U>r744=>SmpF)WLr+b&!3h)IrGK)IsnD&qiEK zQ3zXu@AhZfpCZ&mT_;ET(;||pL5ph}iqLCJnITlbd*^pURokHEXNDqFH8T`#UGt00 znW3nz`C%Z8l_ni@t6nT#Se2NJmRK8^m6)uOvZFtXHr7=Uy}b$c8tl83mK8UIs0@`p zXyIq<94Ls}Vgbk^qo^2DEGm5vbG}0y!dk*4Jt7*R5Vr}XP_Mb^Ym<6mFn#%K)s@1E zpQ1Ade(FlUv^^6HrU%N7Qd8^d_OOWkU=JHt>tI1uk(6zupD zwi=OLY=rwXnwzey#pcdD?t{J;k_AV5y+@b}HSoD-ba9_MwxIhUM@D9N zR5Et7W0o#wo<$-vJmOPvA~Gh`<3EDIOQ_a!$Bh$_5vm?s6Nu4zr;oZB9)Q$b-3-qq zdEjc7P7&K_nBiSrsLb%2QF4Ms<7An)Vsoe7yd}jY7`LLTVV3Mf0W7j&1+68RLqeXU zj9HjNnp#Wr{l<1C3g3(vlXhQ^5hE5h!gW-Y$f3<~U^q{)8lr}bo1YBdmHA0}O654P zZ1KV28K*cU3d#v_ighGjR7m2|HV^V~wnL5PrYj_|xhAJL+14ZD66-4%rj4@!TgU7 zV+Hfq*MhlrmeV)%O#Se=Z`y^wPe&#+4xh{1*Q;c=$EBRZTi6t3jD?f#)0(&AUqV;?ISoSp{23e!rSdcPj;A*^aK) zw+r=(0#cUkCEjJia<|=ahewypsYF|BtawNi-Kwm29?TpeAaJ7&0ReAK2>xsm0(DJ; zz#w4g`avN~tuXj{*F4nh+C0@EScW_|98&?S$>8P;JK`ul6x$YDK=fAknn_$wCr)@ubRB`QUy;O zyXMAd+yiPq+_Frr^P7jlO?&bP2hqa0tT;njwx8#ZJg7(HsO>&6lk+kucUgos$le7C zK+zM@U0e^6*t10$n-cQ4o93^2y=d3ZA=KgR{bAR-yXJ)fz8~Yk?qPevURd=PFlq@! z6(*eSHh{9|>a|Bhc(T3|k1X>g)Wzr%6en6`vGV&o0Q7JDL<`hXp4jdNOQyivz|D4f$(d0bp_#7b(-i=!7N1 zgP^o7voKXdKhg8hH9tzX{{7fBKgI&d4#RqJFSCpf=WqRW8jL~X4(RFunIgIS-uyka zyFMa73vHddU&A`5-)blAcG}L6m1>bpp!~0OKo^aA=sf8(pM27CdfyyZES`nYmM>M1 z1McVd;!nvxeH%Xn64-gFco7d2MzUb1h}bCtcIZYVQF7eMi>#jp5)@R!TcOi0olB>I z79yHTK%=W_VRLTeg2tQVM#h65q7(`MeDYi5>WCZATASZ}MYHl73@G`M9|RRNQg_J~ ze*wriP$phmGtxkad=NwB`BV)+&C`-Kt&{+f9?F2Mk~Kq?0&k~35-=Xts2UpMnU@321L}y$&P~Z|P4rIkh`||F; z=Y{;sck!3!RULx+`#A|pRRae1rdCs9Ilan@Y48XHeU&Yj^1B_2)>bwKQ~m64`qOf{ zUnf~J_j6<+QOU%=vo?>-X}x1zezrHWU%$c`)ZN7=q}QvV^1?Fr`n#5b;>r-x)wB{t z5m{uN@jQO{dBY0dv)SZuY)^leDq0~l0K<7R1qR(N|~P8HfAmM zJ!C(_2F%8MM4_kSXq~l&-@0ExNLXWbheR-p+Lfx5EbDd6?p{sTLNJx@GW| z_dLl0N3|DtiNPyH*apgM^0ky{h<9|^5}8L?xqjjpEYkFm{8x2motQW$CSQkd_u+?8 zmz3~Re)r+lUal$*e%QOVyzTiS;i7XLN)s40JygeS@m#W38IJV_yzRfT^Y9#EN26eK zOh({@oS{JH0;{@ypkB*?GyEZFBvb_>i7Aj{n#OinbtQk z@9JcI^j~U5Xx9Kz1hG-T6o`k4k$gT|5|t4spKp~-fQ*Lwf`&N1Eb4YBr6w8Ei(9>6 zn;Hhp_#*7QeciCVViKgsn~L8>nhaUct)U2tYke9nI&3-lu0!5N*Bg`DA5mUkvr0m$ zW_7-r)xOW_pqkaWFst*L)wya`2i2_F1Hyhk&Z=-?KmdoLqRRs%c+`;kdxmrS$^*~S z>6*nH`8zaz?b6`VmYoPWm+c06%aOHl`1oAXckjHkxT)yfc_U9IOFA(PG*Cyyj}H_s zYp9EeYZrq(#XLm27Vdz0p{Sbnt`~<3hhf7D(gfMEpfzj~x7!@I=Zxd_+zPkb0&dR{ zZnssqJ-5QGJ+LNjnQdZMA(4n12uZ)OLMr&174+=ae4Ku3ZC@x-y86$|ZwINVi6$bmp%p*%14G+!ZGv?dlhCuEEG zorTU<$hHTB>|TSA1;hj)_x23?M#ysvsZSca5%N5QEX}fSglsu72D^{X3AtmF)rF8z zqwKI(&_MaM8X=Dm7txj!^LvW9y%pxbM-z8Ijkzy24aFiI7KZ}}xEL5ATW-`Qal7ES z4Fo#E?Ku^07Xog#3AYOsZqKQ3YY(i6+epZ$yCPiZSIP!@81(&Xk=24%$W276x+yMc z`OVyzOx0�j;x|d$M*Q!7-wZd&ND4cNA2Xr5kpcgEIN| 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
      %;+Frz%DO$ywPQ$C)^BZCGO%@;TJhb^{UQs5n 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
      P$I9`*gzAXa$^6MouC`}F;s9|k;TgpO_Zch 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

      }4GD@=zjHU3Hv&!*tIq{I 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

      |EF173nB0!1H<*dHp3E?CiT4%xi=xb-gH*95 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 eT^90aC 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

      >~{F!ZafauqGNQ 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
    1. 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
      aC3H{qwJW_pm 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 Result<()> { + let args = env::args().collect::>(); + if args.len() != 2 { + println!("Usage: {} in.wasm", args[0]); + return Ok(()); + } + + let buf: Vec = std::fs::read(&args[1])?; + for payload in Parser::new(0).parse_all(&buf) { + match payload? { + Payload::Version { .. } => { + println!("====== Module"); + } + Payload::ExportSection(s) => { + for export in s { + let export = export?; + println!(" Export {} {:?}", export.name, export.kind); + } + } + Payload::ImportSection(s) => { + for import in s { + let import = import?; + println!(" Import {}::{}", import.module, import.name); + } + } + _other => { + // println!("found payload {:?}", _other); + } + } + } + + Ok(()) +} diff --git a/crates/wasmparser/src/binary_reader.rs b/crates/wasmparser/src/binary_reader.rs new file mode 100644 index 000000000..23b0eae57 --- /dev/null +++ b/crates/wasmparser/src/binary_reader.rs @@ -0,0 +1,2847 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{limits::*, *}; +use std::convert::TryInto; +use std::error::Error; +use std::fmt; +use std::ops::Range; +use std::str; + +fn is_name(name: &str, expected: &'static str) -> bool { + name == expected +} + +fn is_name_prefix(name: &str, prefix: &'static str) -> bool { + name.starts_with(prefix) +} + +const WASM_MAGIC_NUMBER: &[u8; 4] = b"\0asm"; + +/// A binary reader for WebAssembly modules. +#[derive(Debug, Clone)] +pub struct BinaryReaderError { + // Wrap the actual error data in a `Box` so that the error is just one + // word. This means that we can continue returning small `Result`s in + // registers. + pub(crate) inner: Box, +} + +#[derive(Debug, Clone)] +pub(crate) struct BinaryReaderErrorInner { + pub(crate) message: String, + pub(crate) offset: usize, + pub(crate) needed_hint: Option, +} + +/// The result for `BinaryReader` operations. +pub type Result = std::result::Result; + +impl Error for BinaryReaderError {} + +impl fmt::Display for BinaryReaderError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "{} (at offset 0x{:x})", + self.inner.message, self.inner.offset + ) + } +} + +impl BinaryReaderError { + #[cold] + pub(crate) fn new(message: impl Into, offset: usize) -> Self { + let message = message.into(); + BinaryReaderError { + inner: Box::new(BinaryReaderErrorInner { + message, + offset, + needed_hint: None, + }), + } + } + + #[cold] + pub(crate) fn eof(offset: usize, needed_hint: usize) -> Self { + BinaryReaderError { + inner: Box::new(BinaryReaderErrorInner { + message: "unexpected end-of-file".to_string(), + offset, + needed_hint: Some(needed_hint), + }), + } + } + + /// Get this error's message. + pub fn message(&self) -> &str { + &self.inner.message + } + + /// Get the offset within the Wasm binary where the error occurred. + pub fn offset(&self) -> usize { + self.inner.offset + } +} + +/// A binary reader of the WebAssembly structures and types. +#[derive(Clone, Debug, Hash)] +pub struct BinaryReader<'a> { + pub(crate) buffer: &'a [u8], + pub(crate) position: usize, + pub(crate) original_offset: usize, + allow_memarg64: bool, +} + +impl<'a> BinaryReader<'a> { + /// Constructs `BinaryReader` type. + /// + /// # Examples + /// ``` + /// let fn_body = &vec![0x41, 0x00, 0x10, 0x00, 0x0B]; + /// let mut reader = wasmparser::BinaryReader::new(fn_body); + /// while !reader.eof() { + /// let op = reader.read_operator(); + /// println!("{:?}", op) + /// } + /// ``` + pub fn new(data: &[u8]) -> BinaryReader { + BinaryReader { + buffer: data, + position: 0, + original_offset: 0, + allow_memarg64: false, + } + } + + /// Constructs a `BinaryReader` with an explicit starting offset. + pub fn new_with_offset(data: &[u8], original_offset: usize) -> BinaryReader { + BinaryReader { + buffer: data, + position: 0, + original_offset, + allow_memarg64: false, + } + } + + /// Gets the original position of the binary reader. + pub fn original_position(&self) -> usize { + self.original_offset + self.position + } + + /// Whether or not to allow 64-bit memory arguments in functions. + /// + /// This is intended to be `true` when support for the memory64 + /// WebAssembly proposal is also enabled. + pub fn allow_memarg64(&mut self, allow: bool) { + self.allow_memarg64 = allow; + } + + /// Returns a range from the starting offset to the end of the buffer. + pub fn range(&self) -> Range { + self.original_offset..self.original_offset + self.buffer.len() + } + + pub(crate) fn remaining_buffer(&self) -> &'a [u8] { + &self.buffer[self.position..] + } + + fn ensure_has_byte(&self) -> Result<()> { + if self.position < self.buffer.len() { + Ok(()) + } else { + Err(BinaryReaderError::eof(self.original_position(), 1)) + } + } + + pub(crate) fn ensure_has_bytes(&self, len: usize) -> Result<()> { + if self.position + len <= self.buffer.len() { + Ok(()) + } else { + let hint = self.position + len - self.buffer.len(); + Err(BinaryReaderError::eof(self.original_position(), hint)) + } + } + + pub(crate) fn read_u7(&mut self) -> Result { + let b = self.read_u8()?; + if (b & 0x80) != 0 { + return Err(BinaryReaderError::new( + "invalid u7", + self.original_position() - 1, + )); + } + Ok(b) + } + + /// Reads a core WebAssembly value type from the binary reader. + pub fn read_val_type(&mut self) -> Result { + match Self::val_type_from_byte(self.peek()?) { + Some(ty) => { + self.position += 1; + Ok(ty) + } + None => Err(BinaryReaderError::new( + "invalid value type", + self.original_position(), + )), + } + } + + pub(crate) fn read_component_start(&mut self) -> Result { + let func_index = self.read_var_u32()?; + let size = self.read_size(MAX_WASM_START_ARGS, "start function arguments")?; + Ok(ComponentStartFunction { + func_index, + arguments: (0..size) + .map(|_| self.read_var_u32()) + .collect::>()?, + }) + } + + fn external_kind_from_byte(byte: u8, offset: usize) -> Result { + match byte { + 0x00 => Ok(ExternalKind::Func), + 0x01 => Ok(ExternalKind::Table), + 0x02 => Ok(ExternalKind::Memory), + 0x03 => Ok(ExternalKind::Global), + 0x04 => Ok(ExternalKind::Tag), + x => Err(Self::invalid_leading_byte_error(x, "external kind", offset)), + } + } + + pub(crate) fn read_external_kind(&mut self) -> Result { + let offset = self.original_position(); + Self::external_kind_from_byte(self.read_u8()?, offset) + } + + fn component_external_kind_from_bytes( + byte1: u8, + byte2: Option, + offset: usize, + ) -> Result { + Ok(match byte1 { + 0x00 => match byte2.unwrap() { + 0x11 => ComponentExternalKind::Module, + x => { + return Err(Self::invalid_leading_byte_error( + x, + "component external kind", + offset + 1, + )) + } + }, + 0x01 => ComponentExternalKind::Func, + 0x02 => ComponentExternalKind::Value, + 0x03 => ComponentExternalKind::Type, + 0x04 => ComponentExternalKind::Component, + 0x05 => ComponentExternalKind::Instance, + x => { + return Err(Self::invalid_leading_byte_error( + x, + "component external kind", + offset, + )) + } + }) + } + + pub(crate) fn read_component_external_kind(&mut self) -> Result { + let offset = self.original_position(); + let byte1 = self.read_u8()?; + let byte2 = if byte1 == 0x00 { + Some(self.read_u8()?) + } else { + None + }; + + Self::component_external_kind_from_bytes(byte1, byte2, offset) + } + + pub(crate) fn read_func_type(&mut self) -> Result { + let params_len = self.read_size(MAX_WASM_FUNCTION_PARAMS, "function params")?; + let mut params = Vec::with_capacity(params_len); + for _ in 0..params_len { + params.push(self.read_val_type()?); + } + let returns_len = self.read_size(MAX_WASM_FUNCTION_RETURNS, "function returns")?; + let mut returns = Vec::with_capacity(returns_len); + for _ in 0..returns_len { + returns.push(self.read_val_type()?); + } + Ok(FuncType { + params: params.into_boxed_slice(), + returns: returns.into_boxed_slice(), + }) + } + + pub(crate) fn read_type(&mut self) -> Result { + Ok(match self.read_u8()? { + 0x60 => Type::Func(self.read_func_type()?), + x => return self.invalid_leading_byte(x, "type"), + }) + } + + pub(crate) fn read_core_type(&mut self) -> Result> { + Ok(match self.read_u8()? { + 0x60 => CoreType::Func(self.read_func_type()?), + 0x50 => { + let size = self.read_size(MAX_WASM_MODULE_TYPE_DECLS, "module type declaration")?; + CoreType::Module( + (0..size) + .map(|_| self.read_module_type_decl()) + .collect::>()?, + ) + } + x => return self.invalid_leading_byte(x, "core type"), + }) + } + + pub(crate) fn read_component_type(&mut self) -> Result> { + Ok(match self.read_u8()? { + 0x40 => ComponentType::Func(ComponentFuncType { + params: self + .read_type_vec(MAX_WASM_FUNCTION_PARAMS, "component function parameters")?, + results: self + .read_type_vec(MAX_WASM_FUNCTION_RETURNS, "component function results")?, + }), + 0x41 => { + let size = + self.read_size(MAX_WASM_COMPONENT_TYPE_DECLS, "component type declaration")?; + ComponentType::Component( + (0..size) + .map(|_| self.read_component_type_decl()) + .collect::>()?, + ) + } + 0x42 => { + let size = + self.read_size(MAX_WASM_INSTANCE_TYPE_DECLS, "instance type declaration")?; + ComponentType::Instance( + (0..size) + .map(|_| self.read_instance_type_decl()) + .collect::>()?, + ) + } + x => { + if let Some(ty) = Self::primitive_val_type_from_byte(x) { + ComponentType::Defined(ComponentDefinedType::Primitive(ty)) + } else { + ComponentType::Defined(self.read_component_defined_type(x)?) + } + } + }) + } + + pub(crate) fn read_type_vec(&mut self, max: usize, desc: &str) -> Result> { + Ok(match self.read_u8()? { + 0x00 => TypeVec::Unnamed(self.read_component_val_type()?), + 0x01 => { + let size = self.read_size(max, desc)?; + TypeVec::Named( + (0..size) + .map(|_| Ok((self.read_string()?, self.read_component_val_type()?))) + .collect::>()?, + ) + } + x => return self.invalid_leading_byte(x, desc), + }) + } + + pub(crate) fn read_module_type_decl(&mut self) -> Result> { + Ok(match self.read_u8()? { + 0x00 => ModuleTypeDeclaration::Import(self.read_import()?), + 0x01 => ModuleTypeDeclaration::Type(self.read_type()?), + 0x02 => ModuleTypeDeclaration::Alias(self.read_alias()?), + 0x03 => ModuleTypeDeclaration::Export { + name: self.read_string()?, + ty: self.read_type_ref()?, + }, + x => return self.invalid_leading_byte(x, "type definition"), + }) + } + + pub(crate) fn read_component_type_decl(&mut self) -> Result> { + // Component types are effectively instance types with the additional + // variant of imports; check for imports here or delegate to + // `read_instance_type_decl` with the appropriate conversions. + if self.peek()? == 0x03 { + self.position += 1; + return Ok(ComponentTypeDeclaration::Import( + self.read_component_import()?, + )); + } + + Ok(match self.read_instance_type_decl()? { + InstanceTypeDeclaration::CoreType(t) => ComponentTypeDeclaration::CoreType(t), + InstanceTypeDeclaration::Type(t) => ComponentTypeDeclaration::Type(t), + InstanceTypeDeclaration::Alias(a) => ComponentTypeDeclaration::Alias(a), + InstanceTypeDeclaration::Export { name, ty } => { + ComponentTypeDeclaration::Export { name, ty } + } + }) + } + + pub(crate) fn read_instance_type_decl(&mut self) -> Result> { + Ok(match self.read_u8()? { + 0x00 => InstanceTypeDeclaration::CoreType(self.read_core_type()?), + 0x01 => InstanceTypeDeclaration::Type(self.read_component_type()?), + 0x02 => InstanceTypeDeclaration::Alias(self.read_component_alias()?), + 0x04 => InstanceTypeDeclaration::Export { + name: self.read_string()?, + ty: self.read_component_type_ref()?, + }, + x => return self.invalid_leading_byte(x, "component or instance type declaration"), + }) + } + + fn primitive_val_type_from_byte(byte: u8) -> Option { + Some(match byte { + 0x7f => PrimitiveValType::Bool, + 0x7e => PrimitiveValType::S8, + 0x7d => PrimitiveValType::U8, + 0x7c => PrimitiveValType::S16, + 0x7b => PrimitiveValType::U16, + 0x7a => PrimitiveValType::S32, + 0x79 => PrimitiveValType::U32, + 0x78 => PrimitiveValType::S64, + 0x77 => PrimitiveValType::U64, + 0x76 => PrimitiveValType::Float32, + 0x75 => PrimitiveValType::Float64, + 0x74 => PrimitiveValType::Char, + 0x73 => PrimitiveValType::String, + _ => return None, + }) + } + + fn read_variant_case(&mut self) -> Result> { + Ok(VariantCase { + name: self.read_string()?, + ty: self.read_optional_val_type()?, + refines: match self.read_u8()? { + 0x0 => None, + 0x1 => Some(self.read_var_u32()?), + x => return self.invalid_leading_byte(x, "variant case refines"), + }, + }) + } + + fn read_component_val_type(&mut self) -> Result { + if let Some(ty) = Self::primitive_val_type_from_byte(self.peek()?) { + self.position += 1; + return Ok(ComponentValType::Primitive(ty)); + } + + Ok(ComponentValType::Type(self.read_var_s33()? as u32)) + } + + fn read_component_defined_type(&mut self, byte: u8) -> Result> { + Ok(match byte { + 0x72 => { + let size = self.read_size(MAX_WASM_RECORD_FIELDS, "record field")?; + ComponentDefinedType::Record( + (0..size) + .map(|_| Ok((self.read_string()?, self.read_component_val_type()?))) + .collect::>()?, + ) + } + 0x71 => { + let size = self.read_size(MAX_WASM_VARIANT_CASES, "variant cases")?; + ComponentDefinedType::Variant( + (0..size) + .map(|_| self.read_variant_case()) + .collect::>()?, + ) + } + 0x70 => ComponentDefinedType::List(self.read_component_val_type()?), + 0x6f => { + let size = self.read_size(MAX_WASM_TUPLE_TYPES, "tuple types")?; + ComponentDefinedType::Tuple( + (0..size) + .map(|_| self.read_component_val_type()) + .collect::>()?, + ) + } + 0x6e => { + let size = self.read_size(MAX_WASM_FLAG_NAMES, "flag names")?; + ComponentDefinedType::Flags( + (0..size) + .map(|_| self.read_string()) + .collect::>()?, + ) + } + 0x6d => { + let size = self.read_size(MAX_WASM_ENUM_CASES, "enum cases")?; + ComponentDefinedType::Enum( + (0..size) + .map(|_| self.read_string()) + .collect::>()?, + ) + } + 0x6c => { + let size = self.read_size(MAX_WASM_UNION_TYPES, "union types")?; + ComponentDefinedType::Union( + (0..size) + .map(|_| self.read_component_val_type()) + .collect::>()?, + ) + } + 0x6b => ComponentDefinedType::Option(self.read_component_val_type()?), + 0x6a => ComponentDefinedType::Result { + ok: self.read_optional_val_type()?, + err: self.read_optional_val_type()?, + }, + x => return self.invalid_leading_byte(x, "component defined type"), + }) + } + + pub(crate) fn read_export(&mut self) -> Result> { + Ok(Export { + name: self.read_string()?, + kind: self.read_external_kind()?, + index: self.read_var_u32()?, + }) + } + + pub(crate) fn read_component_export(&mut self) -> Result> { + Ok(ComponentExport { + name: self.read_string()?, + kind: self.read_component_external_kind()?, + index: self.read_var_u32()?, + }) + } + + pub(crate) fn read_import(&mut self) -> Result> { + Ok(Import { + module: self.read_string()?, + name: self.read_string()?, + ty: self.read_type_ref()?, + }) + } + + pub(crate) fn read_component_import(&mut self) -> Result> { + Ok(ComponentImport { + name: self.read_string()?, + ty: self.read_component_type_ref()?, + }) + } + + pub(crate) fn read_component_type_ref(&mut self) -> Result { + Ok(match self.read_component_external_kind()? { + ComponentExternalKind::Module => ComponentTypeRef::Module(self.read_var_u32()?), + ComponentExternalKind::Func => ComponentTypeRef::Func(self.read_var_u32()?), + ComponentExternalKind::Value => { + ComponentTypeRef::Value(self.read_component_val_type()?) + } + ComponentExternalKind::Type => { + ComponentTypeRef::Type(self.read_type_bounds()?, self.read_var_u32()?) + } + ComponentExternalKind::Instance => ComponentTypeRef::Instance(self.read_var_u32()?), + ComponentExternalKind::Component => ComponentTypeRef::Component(self.read_var_u32()?), + }) + } + + pub(crate) fn read_type_bounds(&mut self) -> Result { + Ok(match self.read_u8()? { + 0x00 => TypeBounds::Eq, + x => return self.invalid_leading_byte(x, "type bound"), + }) + } + + pub(crate) fn read_canonical_func(&mut self) -> Result { + Ok(match self.read_u8()? { + 0x00 => match self.read_u8()? { + 0x00 => CanonicalFunction::Lift { + core_func_index: self.read_var_u32()?, + options: (0..self + .read_size(MAX_WASM_CANONICAL_OPTIONS, "canonical options")?) + .map(|_| self.read_canonical_option()) + .collect::>()?, + type_index: self.read_var_u32()?, + }, + x => return self.invalid_leading_byte(x, "canonical function lift"), + }, + 0x01 => match self.read_u8()? { + 0x00 => CanonicalFunction::Lower { + func_index: self.read_var_u32()?, + options: (0..self + .read_size(MAX_WASM_CANONICAL_OPTIONS, "canonical options")?) + .map(|_| self.read_canonical_option()) + .collect::>()?, + }, + x => return self.invalid_leading_byte(x, "canonical function lower"), + }, + x => return self.invalid_leading_byte(x, "canonical function"), + }) + } + + pub(crate) fn read_canonical_option(&mut self) -> Result { + Ok(match self.read_u8()? { + 0x00 => CanonicalOption::UTF8, + 0x01 => CanonicalOption::UTF16, + 0x02 => CanonicalOption::CompactUTF16, + 0x03 => CanonicalOption::Memory(self.read_var_u32()?), + 0x04 => CanonicalOption::Realloc(self.read_var_u32()?), + 0x05 => CanonicalOption::PostReturn(self.read_var_u32()?), + x => return self.invalid_leading_byte(x, "canonical option"), + }) + } + + pub(crate) fn read_instance(&mut self) -> Result> { + Ok(match self.read_u8()? { + 0x00 => Instance::Instantiate { + module_index: self.read_var_u32()?, + args: (0..self + .read_size(MAX_WASM_INSTANTIATION_ARGS, "core instantiation arguments")?) + .map(|_| self.read_instantiation_arg()) + .collect::>()?, + }, + 0x01 => Instance::FromExports( + (0..self + .read_size(MAX_WASM_INSTANTIATION_EXPORTS, "core instantiation exports")?) + .map(|_| self.read_export()) + .collect::>()?, + ), + x => return self.invalid_leading_byte(x, "core instance"), + }) + } + + pub(crate) fn read_component_instance(&mut self) -> Result> { + Ok(match self.read_u8()? { + 0x00 => ComponentInstance::Instantiate { + component_index: self.read_var_u32()?, + args: (0..self + .read_size(MAX_WASM_INSTANTIATION_ARGS, "instantiation arguments")?) + .map(|_| self.read_component_instantiation_arg()) + .collect::>()?, + }, + 0x01 => ComponentInstance::FromExports( + (0..self.read_size(MAX_WASM_INSTANTIATION_EXPORTS, "instantiation exports")?) + .map(|_| self.read_component_export()) + .collect::>()?, + ), + x => return self.invalid_leading_byte(x, "instance"), + }) + } + + pub(crate) fn read_instantiation_arg_kind(&mut self) -> Result { + Ok(match self.read_u8()? { + 0x12 => InstantiationArgKind::Instance, + x => return self.invalid_leading_byte(x, "instantiation arg kind"), + }) + } + + pub(crate) fn read_instantiation_arg(&mut self) -> Result> { + Ok(InstantiationArg { + name: self.read_string()?, + kind: self.read_instantiation_arg_kind()?, + index: self.read_var_u32()?, + }) + } + + pub(crate) fn read_component_instantiation_arg( + &mut self, + ) -> Result> { + Ok(ComponentInstantiationArg { + name: self.read_string()?, + kind: self.read_component_external_kind()?, + index: self.read_var_u32()?, + }) + } + + pub(crate) fn read_alias(&mut self) -> Result> { + let offset = self.original_position(); + let kind = self.read_u8()?; + + Ok(match self.read_u8()? { + 0x00 => Alias::InstanceExport { + kind: Self::external_kind_from_byte(kind, offset)?, + instance_index: self.read_var_u32()?, + name: self.read_string()?, + }, + 0x01 => Alias::Outer { + kind: match kind { + 0x10 => OuterAliasKind::Type, + x => { + return Err(Self::invalid_leading_byte_error( + x, + "outer alias kind", + offset, + )) + } + }, + count: self.read_var_u32()?, + index: self.read_var_u32()?, + }, + x => return self.invalid_leading_byte(x, "alias"), + }) + } + + fn component_outer_alias_kind_from_bytes( + byte1: u8, + byte2: Option, + offset: usize, + ) -> Result { + Ok(match byte1 { + 0x00 => match byte2.unwrap() { + 0x10 => ComponentOuterAliasKind::CoreType, + 0x11 => ComponentOuterAliasKind::CoreModule, + x => { + return Err(Self::invalid_leading_byte_error( + x, + "component outer alias kind", + offset + 1, + )) + } + }, + 0x03 => ComponentOuterAliasKind::Type, + 0x04 => ComponentOuterAliasKind::Component, + x => { + return Err(Self::invalid_leading_byte_error( + x, + "component outer alias kind", + offset, + )) + } + }) + } + + pub(crate) fn read_component_alias(&mut self) -> Result> { + // We don't know what type of alias it is yet, so just read the sort bytes + let offset = self.original_position(); + let byte1 = self.read_u8()?; + let byte2 = if byte1 == 0x00 { + Some(self.read_u8()?) + } else { + None + }; + + Ok(match self.read_u8()? { + 0x00 => ComponentAlias::InstanceExport { + kind: Self::component_external_kind_from_bytes(byte1, byte2, offset)?, + instance_index: self.read_var_u32()?, + name: self.read_string()?, + }, + 0x01 => ComponentAlias::Outer { + kind: Self::component_outer_alias_kind_from_bytes(byte1, byte2, offset)?, + count: self.read_var_u32()?, + index: self.read_var_u32()?, + }, + x => return self.invalid_leading_byte(x, "alias"), + }) + } + + pub(crate) fn read_type_ref(&mut self) -> Result { + Ok(match self.read_external_kind()? { + ExternalKind::Func => TypeRef::Func(self.read_var_u32()?), + ExternalKind::Table => TypeRef::Table(self.read_table_type()?), + ExternalKind::Memory => TypeRef::Memory(self.read_memory_type()?), + ExternalKind::Global => TypeRef::Global(self.read_global_type()?), + ExternalKind::Tag => TypeRef::Tag(self.read_tag_type()?), + }) + } + + pub(crate) fn read_table_type(&mut self) -> Result { + let element_type = self.read_val_type()?; + let has_max = match self.read_u8()? { + 0x00 => false, + 0x01 => true, + _ => { + return Err(BinaryReaderError::new( + "invalid table resizable limits flags", + self.original_position() - 1, + )) + } + }; + let initial = self.read_var_u32()?; + let maximum = if has_max { + Some(self.read_var_u32()?) + } else { + None + }; + Ok(TableType { + element_type, + initial, + maximum, + }) + } + + pub(crate) fn read_memory_type(&mut self) -> Result { + let pos = self.original_position(); + let flags = self.read_u8()?; + if (flags & !0b111) != 0 { + return Err(BinaryReaderError::new("invalid memory limits flags", pos)); + } + + let memory64 = flags & 0b100 != 0; + let shared = flags & 0b010 != 0; + let has_max = flags & 0b001 != 0; + Ok(MemoryType { + memory64, + shared, + // FIXME(WebAssembly/memory64#21) as currently specified if the + // `shared` flag is set we should be reading a 32-bit limits field + // here. That seems a bit odd to me at the time of this writing so + // I've taken the liberty of reading a 64-bit limits field in those + // situations. I suspect that this is a typo in the spec, but if not + // we'll need to update this to read a 32-bit limits field when the + // shared flag is set. + initial: if memory64 { + self.read_var_u64()? + } else { + self.read_var_u32()?.into() + }, + maximum: if !has_max { + None + } else if memory64 { + Some(self.read_var_u64()?) + } else { + Some(self.read_var_u32()?.into()) + }, + }) + } + + pub(crate) fn read_tag_type(&mut self) -> Result { + let attribute = self.read_u8()?; + if attribute != 0 { + return Err(BinaryReaderError::new( + "invalid tag attributes", + self.original_position() - 1, + )); + } + Ok(TagType { + kind: TagKind::Exception, + func_type_idx: self.read_var_u32()?, + }) + } + + pub(crate) fn read_global_type(&mut self) -> Result { + Ok(GlobalType { + content_type: self.read_val_type()?, + mutable: match self.read_u8()? { + 0x00 => false, + 0x01 => true, + _ => { + return Err(BinaryReaderError::new( + "malformed mutability", + self.original_position() - 1, + )) + } + }, + }) + } + + // Reads a variable-length 32-bit size from the byte stream while checking + // against a limit. + fn read_size(&mut self, limit: usize, desc: &str) -> Result { + let size = self.read_var_u32()? as usize; + if size > limit { + return Err(BinaryReaderError::new( + format!("{} size is out of bounds", desc), + self.original_position() - 4, + )); + } + Ok(size) + } + + fn read_first_byte_and_var_u32(&mut self) -> Result<(u8, u32)> { + let pos = self.position; + let val = self.read_var_u32()?; + Ok((self.buffer[pos], val)) + } + + fn read_memarg(&mut self) -> Result { + let flags_pos = self.original_position(); + let mut flags = self.read_var_u32()?; + let memory = if flags & (1 << 6) != 0 { + flags ^= 1 << 6; + self.read_var_u32()? + } else { + 0 + }; + let align = if flags >= (1 << 6) { + return Err(BinaryReaderError::new("alignment too large", flags_pos)); + } else { + flags as u8 + }; + let offset = if self.allow_memarg64 { + self.read_var_u64()? + } else { + u64::from(self.read_var_u32()?) + }; + Ok(MemoryImmediate { + align, + offset, + memory, + }) + } + + pub(crate) fn read_section_code(&mut self, id: u8, offset: usize) -> Result> { + match id { + 0 => { + let name = self.read_string()?; + let kind = if is_name(name, "name") { + CustomSectionKind::Name + } else if is_name(name, "producers") { + CustomSectionKind::Producers + } else if is_name(name, "sourceMappingURL") { + CustomSectionKind::SourceMappingURL + } else if is_name_prefix(name, "reloc.") { + CustomSectionKind::Reloc + } else if is_name(name, "linking") { + CustomSectionKind::Linking + } else { + CustomSectionKind::Unknown + }; + Ok(SectionCode::Custom { name, kind }) + } + 1 => Ok(SectionCode::Type), + 2 => Ok(SectionCode::Import), + 3 => Ok(SectionCode::Function), + 4 => Ok(SectionCode::Table), + 5 => Ok(SectionCode::Memory), + 6 => Ok(SectionCode::Global), + 7 => Ok(SectionCode::Export), + 8 => Ok(SectionCode::Start), + 9 => Ok(SectionCode::Element), + 10 => Ok(SectionCode::Code), + 11 => Ok(SectionCode::Data), + 12 => Ok(SectionCode::DataCount), + 13 => Ok(SectionCode::Tag), + _ => Err(BinaryReaderError::new("invalid section code", offset)), + } + } + + fn read_br_table(&mut self) -> Result> { + let cnt = self.read_size(MAX_WASM_BR_TABLE_SIZE, "br_table")?; + let start = self.position; + for _ in 0..cnt { + self.read_var_u32()?; + } + let end = self.position; + let default = self.read_var_u32()?; + Ok(BrTable { + reader: BinaryReader::new_with_offset(&self.buffer[start..end], start), + cnt: cnt as u32, + default, + }) + } + + /// Returns whether the `BinaryReader` has reached the end of the file. + pub fn eof(&self) -> bool { + self.position >= self.buffer.len() + } + + /// Returns the `BinaryReader`'s current position. + pub fn current_position(&self) -> usize { + self.position + } + + /// Returns the number of bytes remaining in the `BinaryReader`. + pub fn bytes_remaining(&self) -> usize { + self.buffer.len() - self.position + } + + /// Advances the `BinaryReader` `size` bytes, and returns a slice from the + /// current position of `size` length. + /// + /// # Errors + /// If `size` exceeds the remaining length in `BinaryReader`. + pub fn read_bytes(&mut self, size: usize) -> Result<&'a [u8]> { + self.ensure_has_bytes(size)?; + let start = self.position; + self.position += size; + Ok(&self.buffer[start..self.position]) + } + + /// Advances the `BinaryReader` four bytes and returns a `u32`. + /// # Errors + /// If `BinaryReader` has less than four bytes remaining. + pub fn read_u32(&mut self) -> Result { + self.ensure_has_bytes(4)?; + let word = u32::from_le_bytes( + self.buffer[self.position..self.position + 4] + .try_into() + .unwrap(), + ); + self.position += 4; + Ok(word) + } + + /// Advances the `BinaryReader` eight bytes and returns a `u64`. + /// # Errors + /// If `BinaryReader` has less than eight bytes remaining. + pub fn read_u64(&mut self) -> Result { + self.ensure_has_bytes(8)?; + let word = u64::from_le_bytes( + self.buffer[self.position..self.position + 8] + .try_into() + .unwrap(), + ); + self.position += 8; + Ok(word) + } + + /// Advances the `BinaryReader` a single byte. + /// + /// # Errors + /// + /// If `BinaryReader` has no bytes remaining. + pub fn read_u8(&mut self) -> Result { + let b = match self.buffer.get(self.position) { + Some(b) => *b, + None => return Err(self.eof_err()), + }; + self.position += 1; + Ok(b) + } + + #[cold] + fn eof_err(&self) -> BinaryReaderError { + BinaryReaderError::eof(self.original_position(), 1) + } + + /// Advances the `BinaryReader` up to four bytes to parse a variable + /// length integer as a `u32`. + /// + /// # Errors + /// + /// If `BinaryReader` has less than one or up to four bytes remaining, or + /// the integer is larger than 32 bits. + pub fn read_var_u32(&mut self) -> Result { + // Optimization for single byte i32. + let byte = self.read_u8()?; + if (byte & 0x80) == 0 { + return Ok(byte as u32); + } + + let mut result = (byte & 0x7F) as u32; + let mut shift = 7; + loop { + let byte = self.read_u8()?; + result |= ((byte & 0x7F) as u32) << shift; + if shift >= 25 && (byte >> (32 - shift)) != 0 { + let msg = if byte & 0x80 != 0 { + "invalid var_u32: integer representation too long" + } else { + "invalid var_u32: integer too large" + }; + // The continuation bit or unused bits are set. + return Err(BinaryReaderError::new(msg, self.original_position() - 1)); + } + shift += 7; + if (byte & 0x80) == 0 { + break; + } + } + Ok(result) + } + + /// Advances the `BinaryReader` up to four bytes to parse a variable + /// length integer as a `u64`. + /// + /// # Errors + /// + /// If `BinaryReader` has less than one or up to eight bytes remaining, or + /// the integer is larger than 64 bits. + pub fn read_var_u64(&mut self) -> Result { + // Optimization for single byte u64. + let byte = u64::from(self.read_u8()?); + if (byte & 0x80) == 0 { + return Ok(byte); + } + + let mut result = byte & 0x7F; + let mut shift = 7; + loop { + let byte = u64::from(self.read_u8()?); + result |= (byte & 0x7F) << shift; + if shift >= 57 && (byte >> (64 - shift)) != 0 { + let msg = if byte & 0x80 != 0 { + "invalid var_u64: integer representation too long" + } else { + "invalid var_u64: integer too large" + }; + // The continuation bit or unused bits are set. + return Err(BinaryReaderError::new(msg, self.original_position() - 1)); + } + shift += 7; + if (byte & 0x80) == 0 { + break; + } + } + Ok(result) + } + + /// Advances the `BinaryReader` `len` bytes, skipping the result. + /// # Errors + /// If `BinaryReader` has less than `len` bytes remaining. + pub fn skip_bytes(&mut self, len: usize) -> Result<()> { + self.ensure_has_bytes(len)?; + self.position += len; + Ok(()) + } + + /// Advances the `BinaryReader` past a WebAssembly string. This method does + /// not perform any utf-8 validation. + /// # Errors + /// If `BinaryReader` has less than four bytes, the string's length exceeds + /// the remaining bytes, or the string length + /// exceeds `limits::MAX_WASM_STRING_SIZE`. + pub fn skip_string(&mut self) -> Result<()> { + let len = self.read_var_u32()? as usize; + if len > MAX_WASM_STRING_SIZE { + return Err(BinaryReaderError::new( + "string size out of bounds", + self.original_position() - 1, + )); + } + self.skip_bytes(len) + } + + pub(crate) fn skip_to(&mut self, position: usize) { + assert!( + self.position <= position && position <= self.buffer.len(), + "skip_to allowed only into region past current position" + ); + self.position = position; + } + + /// Advances the `BinaryReader` up to four bytes to parse a variable + /// length integer as a `i32`. + /// # Errors + /// If `BinaryReader` has less than one or up to four bytes remaining, or + /// the integer is larger than 32 bits. + pub fn read_var_i32(&mut self) -> Result { + // Optimization for single byte i32. + let byte = self.read_u8()?; + if (byte & 0x80) == 0 { + return Ok(((byte as i32) << 25) >> 25); + } + + let mut result = (byte & 0x7F) as i32; + let mut shift = 7; + loop { + let byte = self.read_u8()?; + result |= ((byte & 0x7F) as i32) << shift; + if shift >= 25 { + let continuation_bit = (byte & 0x80) != 0; + let sign_and_unused_bit = (byte << 1) as i8 >> (32 - shift); + if continuation_bit || (sign_and_unused_bit != 0 && sign_and_unused_bit != -1) { + let msg = if continuation_bit { + "invalid var_i32: integer representation too long" + } else { + "invalid var_i32: integer too large" + }; + return Err(BinaryReaderError::new(msg, self.original_position() - 1)); + } + return Ok(result); + } + shift += 7; + if (byte & 0x80) == 0 { + break; + } + } + let ashift = 32 - shift; + Ok((result << ashift) >> ashift) + } + + /// Advances the `BinaryReader` up to four bytes to parse a variable + /// length integer as a signed 33 bit integer, returned as a `i64`. + /// # Errors + /// If `BinaryReader` has less than one or up to five bytes remaining, or + /// the integer is larger than 33 bits. + pub fn read_var_s33(&mut self) -> Result { + // Optimization for single byte. + let byte = self.read_u8()?; + if (byte & 0x80) == 0 { + return Ok(((byte as i8) << 1) as i64 >> 1); + } + + let mut result = (byte & 0x7F) as i64; + let mut shift = 7; + loop { + let byte = self.read_u8()?; + result |= ((byte & 0x7F) as i64) << shift; + if shift >= 25 { + let continuation_bit = (byte & 0x80) != 0; + let sign_and_unused_bit = (byte << 1) as i8 >> (33 - shift); + if continuation_bit || (sign_and_unused_bit != 0 && sign_and_unused_bit != -1) { + return Err(BinaryReaderError::new( + "invalid var_s33: integer representation too long", + self.original_position() - 1, + )); + } + return Ok(result); + } + shift += 7; + if (byte & 0x80) == 0 { + break; + } + } + let ashift = 64 - shift; + Ok((result << ashift) >> ashift) + } + + /// Advances the `BinaryReader` up to eight bytes to parse a variable + /// length integer as a 64 bit integer, returned as a `i64`. + /// # Errors + /// If `BinaryReader` has less than one or up to eight bytes remaining, or + /// the integer is larger than 64 bits. + pub fn read_var_i64(&mut self) -> Result { + let mut result: i64 = 0; + let mut shift = 0; + loop { + let byte = self.read_u8()?; + result |= i64::from(byte & 0x7F) << shift; + if shift >= 57 { + let continuation_bit = (byte & 0x80) != 0; + let sign_and_unused_bit = ((byte << 1) as i8) >> (64 - shift); + if continuation_bit || (sign_and_unused_bit != 0 && sign_and_unused_bit != -1) { + let msg = if continuation_bit { + "invalid var_i64: integer representation too long" + } else { + "invalid var_i64: integer too large" + }; + return Err(BinaryReaderError::new(msg, self.original_position() - 1)); + } + return Ok(result); + } + shift += 7; + if (byte & 0x80) == 0 { + break; + } + } + let ashift = 64 - shift; + Ok((result << ashift) >> ashift) + } + + /// Advances the `BinaryReader` up to four bytes to parse a variable + /// length integer as a 32 bit floating point integer, returned as `Ieee32`. + /// # Errors + /// If `BinaryReader` has less than one or up to four bytes remaining, or + /// the integer is larger than 32 bits. + pub fn read_f32(&mut self) -> Result { + let value = self.read_u32()?; + Ok(Ieee32(value)) + } + + /// Advances the `BinaryReader` up to four bytes to parse a variable + /// length integer as a 32 bit floating point integer, returned as `Ieee32`. + /// # Errors + /// If `BinaryReader` has less than one or up to four bytes remaining, or + /// the integer is larger than 32 bits. + pub fn read_f64(&mut self) -> Result { + let value = self.read_u64()?; + Ok(Ieee64(value)) + } + + /// Reads a WebAssembly string from the module. + /// # Errors + /// If `BinaryReader` has less than up to four bytes remaining, the string's + /// length exceeds the remaining bytes, the string's length exceeds + /// `limits::MAX_WASM_STRING_SIZE`, or the string contains invalid utf-8. + pub fn read_string(&mut self) -> Result<&'a str> { + let len = self.read_var_u32()? as usize; + if len > MAX_WASM_STRING_SIZE { + return Err(BinaryReaderError::new( + "string size out of bounds", + self.original_position() - 1, + )); + } + let bytes = self.read_bytes(len)?; + str::from_utf8(bytes).map_err(|_| { + BinaryReaderError::new("invalid UTF-8 encoding", self.original_position() - 1) + }) + } + + fn read_optional_val_type(&mut self) -> Result> { + match self.read_u8()? { + 0x0 => Ok(None), + 0x1 => Ok(Some(self.read_component_val_type()?)), + x => self.invalid_leading_byte(x, "optional component value type"), + } + } + + fn read_memarg_of_align(&mut self, max_align: u8) -> Result { + let align_pos = self.original_position(); + let imm = self.read_memarg()?; + if imm.align > max_align { + return Err(BinaryReaderError::new( + "alignment must not be larger than natural", + align_pos, + )); + } + Ok(imm) + } + + #[cold] + fn invalid_leading_byte(&self, byte: u8, desc: &str) -> Result { + Err(Self::invalid_leading_byte_error( + byte, + desc, + self.original_position() - 1, + )) + } + + #[cold] + fn invalid_leading_byte_error(byte: u8, desc: &str, offset: usize) -> BinaryReaderError { + BinaryReaderError::new( + format!("invalid leading byte (0x{:x}) for {}", byte, desc), + offset, + ) + } + + fn peek(&self) -> Result { + self.ensure_has_byte()?; + Ok(self.buffer[self.position]) + } + + fn val_type_from_byte(byte: u8) -> Option { + match byte { + 0x7F => Some(ValType::I32), + 0x7E => Some(ValType::I64), + 0x7D => Some(ValType::F32), + 0x7C => Some(ValType::F64), + 0x7B => Some(ValType::V128), + 0x70 => Some(ValType::FuncRef), + 0x6F => Some(ValType::ExternRef), + _ => None, + } + } + + fn read_block_type(&mut self) -> Result { + let b = self.peek()?; + + // Check for empty block + if b == 0x40 { + self.position += 1; + return Ok(BlockType::Empty); + } + + // Check for a block type of form [] -> [t]. + if let Some(ty) = Self::val_type_from_byte(b) { + self.position += 1; + return Ok(BlockType::Type(ty)); + } + + // Not empty or a singular type, so read the function type index + let idx = self.read_var_s33()?; + if idx < 0 || idx > (std::u32::MAX as i64) { + return Err(BinaryReaderError::new( + "invalid function type", + self.original_position(), + )); + } + + Ok(BlockType::FuncType(idx as u32)) + } + + /// Reads the next available `Operator` and calls the respective visit method. + /// + /// # Errors + /// + /// If `BinaryReader` has less bytes remaining than required to parse + /// the `Operator`. + #[rustfmt::skip] + pub fn visit_operator(&mut self, visitor: &mut T) -> Result<>::Output> + where + T: VisitOperator<'a>, + { + let pos = self.original_position(); + let code = self.read_u8()? as u8; + Ok(match code { + 0x00 => visitor.visit_unreachable(pos), + 0x01 => visitor.visit_nop(pos), + 0x02 => visitor.visit_block(pos, self.read_block_type()?), + 0x03 => visitor.visit_loop(pos, self.read_block_type()?), + 0x04 => visitor.visit_if(pos, self.read_block_type()?), + 0x05 => visitor.visit_else(pos), + 0x06 => visitor.visit_try(pos, self.read_block_type()?), + 0x07 => visitor.visit_catch(pos, self.read_var_u32()?), + 0x08 => visitor.visit_throw(pos, self.read_var_u32()?), + 0x09 => visitor.visit_rethrow(pos, self.read_var_u32()?), + 0x0b => visitor.visit_end(pos), + 0x0c => visitor.visit_br(pos, self.read_var_u32()?), + 0x0d => visitor.visit_br_if(pos, self.read_var_u32()?), + 0x0e => visitor.visit_br_table(pos, &self.read_br_table()?), + 0x0f => visitor.visit_return(pos), + 0x10 => visitor.visit_call(pos, self.read_var_u32()?), + 0x11 => { + let index = self.read_var_u32()?; + let (table_byte, table_index) = self.read_first_byte_and_var_u32()?; + visitor.visit_call_indirect(pos, index, table_index, table_byte) + } + 0x12 => visitor.visit_return_call(pos, self.read_var_u32()?), + 0x13 => visitor.visit_return_call_indirect(pos, self.read_var_u32()?, self.read_var_u32()?), + 0x18 => visitor.visit_delegate(pos, self.read_var_u32()?), + 0x19 => visitor.visit_catch_all(pos), + 0x1a => visitor.visit_drop(pos), + 0x1b => visitor.visit_select(pos), + 0x1c => { + let results = self.read_var_u32()?; + if results != 1 { + return Err(BinaryReaderError::new( + "invalid result arity", + self.position, + )); + } + visitor.visit_typed_select(pos, self.read_val_type()?) + } + + 0x20 => visitor.visit_local_get(pos, self.read_var_u32()?), + 0x21 => visitor.visit_local_set(pos, self.read_var_u32()?), + 0x22 => visitor.visit_local_tee(pos, self.read_var_u32()?), + 0x23 => visitor.visit_global_get(pos, self.read_var_u32()?), + 0x24 => visitor.visit_global_set(pos, self.read_var_u32()?), + 0x25 => visitor.visit_table_get(pos, self.read_var_u32()?), + 0x26 => visitor.visit_table_set(pos, self.read_var_u32()?), + + 0x28 => visitor.visit_i32_load(pos, self.read_memarg()?), + 0x29 => visitor.visit_i64_load(pos, self.read_memarg()?), + 0x2a => visitor.visit_f32_load(pos, self.read_memarg()?), + 0x2b => visitor.visit_f64_load(pos, self.read_memarg()?), + 0x2c => visitor.visit_i32_load8_s(pos, self.read_memarg()?), + 0x2d => visitor.visit_i32_load8_u(pos, self.read_memarg()?), + 0x2e => visitor.visit_i32_load16_s(pos, self.read_memarg()?), + 0x2f => visitor.visit_i32_load16_u(pos, self.read_memarg()?), + 0x30 => visitor.visit_i64_load8_s(pos, self.read_memarg()?), + 0x31 => visitor.visit_i64_load8_u(pos, self.read_memarg()?), + 0x32 => visitor.visit_i64_load16_s(pos, self.read_memarg()?), + 0x33 => visitor.visit_i64_load16_u(pos, self.read_memarg()?), + 0x34 => visitor.visit_i64_load32_s(pos, self.read_memarg()?), + 0x35 => visitor.visit_i64_load32_u(pos, self.read_memarg()?), + 0x36 => visitor.visit_i32_store(pos, self.read_memarg()?), + 0x37 => visitor.visit_i64_store(pos, self.read_memarg()?), + 0x38 => visitor.visit_f32_store(pos, self.read_memarg()?), + 0x39 => visitor.visit_f64_store(pos, self.read_memarg()?), + 0x3a => visitor.visit_i32_store8(pos, self.read_memarg()?), + 0x3b => visitor.visit_i32_store16(pos, self.read_memarg()?), + 0x3c => visitor.visit_i64_store8(pos, self.read_memarg()?), + 0x3d => visitor.visit_i64_store16(pos, self.read_memarg()?), + 0x3e => visitor.visit_i64_store32(pos, self.read_memarg()?), + 0x3f => { + let (mem_byte, mem) = self.read_first_byte_and_var_u32()?; + visitor.visit_memory_size(pos, mem, mem_byte) + } + 0x40 => { + let (mem_byte, mem) = self.read_first_byte_and_var_u32()?; + visitor.visit_memory_grow(pos, mem, mem_byte) + } + + 0x41 => visitor.visit_i32_const(pos, self.read_var_i32()?), + 0x42 => visitor.visit_i64_const(pos, self.read_var_i64()?), + 0x43 => visitor.visit_f32_const(pos, self.read_f32()?), + 0x44 => visitor.visit_f64_const(pos, self.read_f64()?), + + 0x45 => visitor.visit_i32_eqz(pos), + 0x46 => visitor.visit_i32_eq(pos), + 0x47 => visitor.visit_i32_ne(pos), + 0x48 => visitor.visit_i32_lt_s(pos), + 0x49 => visitor.visit_i32_lt_u(pos), + 0x4a => visitor.visit_i32_gt_s(pos), + 0x4b => visitor.visit_i32_gt_u(pos), + 0x4c => visitor.visit_i32_le_s(pos), + 0x4d => visitor.visit_i32_le_u(pos), + 0x4e => visitor.visit_i32_ge_s(pos), + 0x4f => visitor.visit_i32_ge_u(pos), + 0x50 => visitor.visit_i64_eqz(pos), + 0x51 => visitor.visit_i64_eq(pos), + 0x52 => visitor.visit_i64_ne(pos), + 0x53 => visitor.visit_i64_lt_s(pos), + 0x54 => visitor.visit_i64_lt_u(pos), + 0x55 => visitor.visit_i64_gt_s(pos), + 0x56 => visitor.visit_i64_gt_u(pos), + 0x57 => visitor.visit_i64_le_s(pos), + 0x58 => visitor.visit_i64_le_u(pos), + 0x59 => visitor.visit_i64_ge_s(pos), + 0x5a => visitor.visit_i64_ge_u(pos), + 0x5b => visitor.visit_f32_eq(pos), + 0x5c => visitor.visit_f32_ne(pos), + 0x5d => visitor.visit_f32_lt(pos), + 0x5e => visitor.visit_f32_gt(pos), + 0x5f => visitor.visit_f32_le(pos), + 0x60 => visitor.visit_f32_ge(pos), + 0x61 => visitor.visit_f64_eq(pos), + 0x62 => visitor.visit_f64_ne(pos), + 0x63 => visitor.visit_f64_lt(pos), + 0x64 => visitor.visit_f64_gt(pos), + 0x65 => visitor.visit_f64_le(pos), + 0x66 => visitor.visit_f64_ge(pos), + 0x67 => visitor.visit_i32_clz(pos), + 0x68 => visitor.visit_i32_ctz(pos), + 0x69 => visitor.visit_i32_popcnt(pos), + 0x6a => visitor.visit_i32_add(pos), + 0x6b => visitor.visit_i32_sub(pos), + 0x6c => visitor.visit_i32_mul(pos), + 0x6d => visitor.visit_i32_div_s(pos), + 0x6e => visitor.visit_i32_div_u(pos), + 0x6f => visitor.visit_i32_rem_s(pos), + 0x70 => visitor.visit_i32_rem_u(pos), + 0x71 => visitor.visit_i32_and(pos), + 0x72 => visitor.visit_i32_or(pos), + 0x73 => visitor.visit_i32_xor(pos), + 0x74 => visitor.visit_i32_shl(pos), + 0x75 => visitor.visit_i32_shr_s(pos), + 0x76 => visitor.visit_i32_shr_u(pos), + 0x77 => visitor.visit_i32_rotl(pos), + 0x78 => visitor.visit_i32_rotr(pos), + 0x79 => visitor.visit_i64_clz(pos), + 0x7a => visitor.visit_i64_ctz(pos), + 0x7b => visitor.visit_i64_popcnt(pos), + 0x7c => visitor.visit_i64_add(pos), + 0x7d => visitor.visit_i64_sub(pos), + 0x7e => visitor.visit_i64_mul(pos), + 0x7f => visitor.visit_i64_div_s(pos), + 0x80 => visitor.visit_i64_div_u(pos), + 0x81 => visitor.visit_i64_rem_s(pos), + 0x82 => visitor.visit_i64_rem_u(pos), + 0x83 => visitor.visit_i64_and(pos), + 0x84 => visitor.visit_i64_or(pos), + 0x85 => visitor.visit_i64_xor(pos), + 0x86 => visitor.visit_i64_shl(pos), + 0x87 => visitor.visit_i64_shr_s(pos), + 0x88 => visitor.visit_i64_shr_u(pos), + 0x89 => visitor.visit_i64_rotl(pos), + 0x8a => visitor.visit_i64_rotr(pos), + 0x8b => visitor.visit_f32_abs(pos), + 0x8c => visitor.visit_f32_neg(pos), + 0x8d => visitor.visit_f32_ceil(pos), + 0x8e => visitor.visit_f32_floor(pos), + 0x8f => visitor.visit_f32_trunc(pos), + 0x90 => visitor.visit_f32_nearest(pos), + 0x91 => visitor.visit_f32_sqrt(pos), + 0x92 => visitor.visit_f32_add(pos), + 0x93 => visitor.visit_f32_sub(pos), + 0x94 => visitor.visit_f32_mul(pos), + 0x95 => visitor.visit_f32_div(pos), + 0x96 => visitor.visit_f32_min(pos), + 0x97 => visitor.visit_f32_max(pos), + 0x98 => visitor.visit_f32_copysign(pos), + 0x99 => visitor.visit_f64_abs(pos), + 0x9a => visitor.visit_f64_neg(pos), + 0x9b => visitor.visit_f64_ceil(pos), + 0x9c => visitor.visit_f64_floor(pos), + 0x9d => visitor.visit_f64_trunc(pos), + 0x9e => visitor.visit_f64_nearest(pos), + 0x9f => visitor.visit_f64_sqrt(pos), + 0xa0 => visitor.visit_f64_add(pos), + 0xa1 => visitor.visit_f64_sub(pos), + 0xa2 => visitor.visit_f64_mul(pos), + 0xa3 => visitor.visit_f64_div(pos), + 0xa4 => visitor.visit_f64_min(pos), + 0xa5 => visitor.visit_f64_max(pos), + 0xa6 => visitor.visit_f64_copysign(pos), + 0xa7 => visitor.visit_i32_wrap_i64(pos), + 0xa8 => visitor.visit_i32_trunc_f32s(pos), + 0xa9 => visitor.visit_i32_trunc_f32u(pos), + 0xaa => visitor.visit_i32_trunc_f64s(pos), + 0xab => visitor.visit_i32_trunc_f64u(pos), + 0xac => visitor.visit_i64_extend_i32s(pos), + 0xad => visitor.visit_i64_extend_i32u(pos), + 0xae => visitor.visit_i64_trunc_f32s(pos), + 0xaf => visitor.visit_i64_trunc_f32u(pos), + 0xb0 => visitor.visit_i64_trunc_f64s(pos), + 0xb1 => visitor.visit_i64_trunc_f64u(pos), + 0xb2 => visitor.visit_f32_convert_i32s(pos), + 0xb3 => visitor.visit_f32_convert_i32u(pos), + 0xb4 => visitor.visit_f32_convert_i64s(pos), + 0xb5 => visitor.visit_f32_convert_i64u(pos), + 0xb6 => visitor.visit_f32_demote_f64(pos), + 0xb7 => visitor.visit_f64_convert_i32s(pos), + 0xb8 => visitor.visit_f64_convert_i32u(pos), + 0xb9 => visitor.visit_f64_convert_i64s(pos), + 0xba => visitor.visit_f64_convert_i64u(pos), + 0xbb => visitor.visit_f64_promote_f32(pos), + 0xbc => visitor.visit_i32_reinterpret_f32(pos), + 0xbd => visitor.visit_i64_reinterpret_f64(pos), + 0xbe => visitor.visit_f32_reinterpret_i32(pos), + 0xbf => visitor.visit_f64_reinterpret_i64(pos), + + 0xc0 => visitor.visit_i32_extend8_s(pos), + 0xc1 => visitor.visit_i32_extend16_s(pos), + 0xc2 => visitor.visit_i64_extend8_s(pos), + 0xc3 => visitor.visit_i64_extend16_s(pos), + 0xc4 => visitor.visit_i64_extend32_s(pos), + + 0xd0 => visitor.visit_ref_null(pos, self.read_val_type()?), + 0xd1 => visitor.visit_ref_is_null(pos), + 0xd2 => visitor.visit_ref_func(pos, self.read_var_u32()?), + + 0xf1 => self.visit_0xf1_operator(visitor)?, + + 0xfc => self.visit_0xfc_operator(visitor)?, + 0xfd => self.visit_0xfd_operator(visitor)?, + 0xfe => self.visit_0xfe_operator(visitor)?, + + _ => { + return Err(BinaryReaderError::new( + format!("illegal opcode: 0x{:x}", code), + self.original_position() - 1, + )); + } + }) + } + + #[rustfmt::skip] + fn visit_0xfc_operator(&mut self, visitor: &mut T) -> Result<>::Output> + where + T: VisitOperator<'a>, + { + let pos = self.original_position(); + let code = self.read_var_u32()?; + Ok(match code { + 0x00 => visitor.visit_i32_trunc_sat_f32s(pos), + 0x01 => visitor.visit_i32_trunc_sat_f32u(pos), + 0x02 => visitor.visit_i32_trunc_sat_f64s(pos), + 0x03 => visitor.visit_i32_trunc_sat_f64u(pos), + 0x04 => visitor.visit_i64_trunc_sat_f32s(pos), + 0x05 => visitor.visit_i64_trunc_sat_f32u(pos), + 0x06 => visitor.visit_i64_trunc_sat_f64s(pos), + 0x07 => visitor.visit_i64_trunc_sat_f64u(pos), + + 0x08 => { + let segment = self.read_var_u32()?; + let mem = self.read_var_u32()?; + visitor.visit_memory_init(pos, segment,mem) + } + 0x09 => { + let segment = self.read_var_u32()?; + visitor.visit_data_drop(pos, segment) + } + 0x0a => { + let dst = self.read_var_u32()?; + let src = self.read_var_u32()?; + visitor.visit_memory_copy(pos, dst,src) + } + 0x0b => { + let mem = self.read_var_u32()?; + visitor.visit_memory_fill(pos, mem) + } + 0x0c => { + let segment = self.read_var_u32()?; + let table = self.read_var_u32()?; + visitor.visit_table_init(pos, segment, table) + } + 0x0d => { + let segment = self.read_var_u32()?; + visitor.visit_elem_drop(pos, segment) + } + 0x0e => { + let dst_table = self.read_var_u32()?; + let src_table = self.read_var_u32()?; + visitor.visit_table_copy(pos, dst_table, src_table) + } + + 0x0f => { + let table = self.read_var_u32()?; + visitor.visit_table_grow(pos, table) + } + 0x10 => { + let table = self.read_var_u32()?; + visitor.visit_table_size(pos, table) + } + + 0x11 => { + let table = self.read_var_u32()?; + visitor.visit_table_fill(pos, table) + } + + _ => { + return Err(BinaryReaderError::new( + format!("unknown 0xfc subopcode: 0x{:x}", code), + self.original_position() - 1, + )); + } + }) + } + + #[rustfmt::skip] + fn visit_0xfd_operator(&mut self, visitor: &mut T) -> Result<>::Output> + where + T: VisitOperator<'a>, + { + let pos = self.original_position(); + let code = self.read_var_u32()?; + Ok(match code { + 0x00 => visitor.visit_v128_load(pos, self.read_memarg()?), + 0x01 => visitor.visit_v128_load8x8_s(pos, self.read_memarg_of_align(3)?), + 0x02 => visitor.visit_v128_load8x8_u(pos, self.read_memarg_of_align(3)?), + 0x03 => visitor.visit_v128_load16x4_s(pos, self.read_memarg_of_align(3)?), + 0x04 => visitor.visit_v128_load16x4_u(pos, self.read_memarg_of_align(3)?), + 0x05 => visitor.visit_v128_load32x2_s(pos, self.read_memarg_of_align(3)?), + 0x06 => visitor.visit_v128_load32x2_u(pos, self.read_memarg_of_align(3)?), + 0x07 => visitor.visit_v128_load8_splat(pos, self.read_memarg_of_align(0)?), + 0x08 => visitor.visit_v128_load16_splat(pos, self.read_memarg_of_align(1)?), + 0x09 => visitor.visit_v128_load32_splat(pos, self.read_memarg_of_align(2)?), + 0x0a => visitor.visit_v128_load64_splat(pos, self.read_memarg_of_align(3)?), + + 0x0b => visitor.visit_v128_store(pos, self.read_memarg()?), + 0x0c => visitor.visit_v128_const(pos, self.read_v128()?), + 0x0d => { + let mut lanes: [SIMDLaneIndex; 16] = [0; 16]; + for lane in &mut lanes { + *lane = self.read_lane_index(32)? + } + visitor.visit_i8x16_shuffle(pos, lanes) + } + + 0x0e => visitor.visit_i8x16_swizzle(pos), + 0x0f => visitor.visit_i8x16_splat(pos), + 0x10 => visitor.visit_i16x8_splat(pos), + 0x11 => visitor.visit_i32x4_splat(pos), + 0x12 => visitor.visit_i64x2_splat(pos), + 0x13 => visitor.visit_f32x4_splat(pos), + 0x14 => visitor.visit_f64x2_splat(pos), + + 0x15 => visitor.visit_i8x16_extract_lane_s(pos, self.read_lane_index(16)?), + 0x16 => visitor.visit_i8x16_extract_lane_u(pos, self.read_lane_index(16)?), + 0x17 => visitor.visit_i8x16_replace_lane(pos, self.read_lane_index(16)?), + 0x18 => visitor.visit_i16x8_extract_lane_s(pos, self.read_lane_index(8)?), + 0x19 => visitor.visit_i16x8_extract_lane_u(pos, self.read_lane_index(8)?), + 0x1a => visitor.visit_i16x8_replace_lane(pos, self.read_lane_index(8)?), + 0x1b => visitor.visit_i32x4_extract_lane(pos, self.read_lane_index(4)?), + + 0x1c => visitor.visit_i32x4_replace_lane(pos, self.read_lane_index(4)?), + 0x1d => visitor.visit_i64x2_extract_lane(pos, self.read_lane_index(2)?), + 0x1e => visitor.visit_i64x2_replace_lane(pos, self.read_lane_index(2)?), + 0x1f => visitor.visit_f32x4_extract_lane(pos, self.read_lane_index(4)?), + 0x20 => visitor.visit_f32x4_replace_lane(pos, self.read_lane_index(4)?), + 0x21 => visitor.visit_f64x2_extract_lane(pos, self.read_lane_index(2)?), + 0x22 => visitor.visit_f64x2_replace_lane(pos, self.read_lane_index(2)?), + + 0x23 => visitor.visit_i8x16_eq(pos), + 0x24 => visitor.visit_i8x16_ne(pos), + 0x25 => visitor.visit_i8x16_lt_s(pos), + 0x26 => visitor.visit_i8x16_lt_u(pos), + 0x27 => visitor.visit_i8x16_gt_s(pos), + 0x28 => visitor.visit_i8x16_gt_u(pos), + 0x29 => visitor.visit_i8x16_le_s(pos), + 0x2a => visitor.visit_i8x16_le_u(pos), + 0x2b => visitor.visit_i8x16_ge_s(pos), + 0x2c => visitor.visit_i8x16_ge_u(pos), + 0x2d => visitor.visit_i16x8_eq(pos), + 0x2e => visitor.visit_i16x8_ne(pos), + 0x2f => visitor.visit_i16x8_lt_s(pos), + 0x30 => visitor.visit_i16x8_lt_u(pos), + 0x31 => visitor.visit_i16x8_gt_s(pos), + 0x32 => visitor.visit_i16x8_gt_u(pos), + 0x33 => visitor.visit_i16x8_le_s(pos), + 0x34 => visitor.visit_i16x8_le_u(pos), + 0x35 => visitor.visit_i16x8_ge_s(pos), + 0x36 => visitor.visit_i16x8_ge_u(pos), + 0x37 => visitor.visit_i32x4_eq(pos), + 0x38 => visitor.visit_i32x4_ne(pos), + 0x39 => visitor.visit_i32x4_lt_s(pos), + 0x3a => visitor.visit_i32x4_lt_u(pos), + 0x3b => visitor.visit_i32x4_gt_s(pos), + 0x3c => visitor.visit_i32x4_gt_u(pos), + 0x3d => visitor.visit_i32x4_le_s(pos), + 0x3e => visitor.visit_i32x4_le_u(pos), + 0x3f => visitor.visit_i32x4_ge_s(pos), + 0x40 => visitor.visit_i32x4_ge_u(pos), + 0x41 => visitor.visit_f32x4_eq(pos), + 0x42 => visitor.visit_f32x4_ne(pos), + 0x43 => visitor.visit_f32x4_lt(pos), + 0x44 => visitor.visit_f32x4_gt(pos), + 0x45 => visitor.visit_f32x4_le(pos), + 0x46 => visitor.visit_f32x4_ge(pos), + 0x47 => visitor.visit_f64x2_eq(pos), + 0x48 => visitor.visit_f64x2_ne(pos), + 0x49 => visitor.visit_f64x2_lt(pos), + 0x4a => visitor.visit_f64x2_gt(pos), + 0x4b => visitor.visit_f64x2_le(pos), + 0x4c => visitor.visit_f64x2_ge(pos), + 0x4d => visitor.visit_v128_not(pos), + 0x4e => visitor.visit_v128_and(pos), + 0x4f => visitor.visit_v128_and_not(pos), + 0x50 => visitor.visit_v128_or(pos), + 0x51 => visitor.visit_v128_xor(pos), + 0x52 => visitor.visit_v128_bitselect(pos), + 0x53 => visitor.visit_v128_any_true(pos), + + 0x54 => { + let memarg = self.read_memarg()?; + let lane = self.read_lane_index(16)?; + visitor.visit_v128_load8_lane(pos, memarg, lane) + }, + 0x55 => { + let memarg = self.read_memarg()?; + let lane = self.read_lane_index(8)?; + visitor.visit_v128_load16_lane(pos, memarg, lane) + }, + 0x56 => { + let memarg = self.read_memarg()?; + let lane = self.read_lane_index(4)?; + visitor.visit_v128_load32_lane(pos, memarg, lane) + }, + 0x57 => { + let memarg = self.read_memarg()?; + let lane = self.read_lane_index(2)?; + visitor.visit_v128_load64_lane(pos, memarg, lane) + }, + 0x58 => { + let memarg = self.read_memarg()?; + let lane = self.read_lane_index(16)?; + visitor.visit_v128_store8_lane(pos, memarg, lane) + }, + 0x59 => { + let memarg = self.read_memarg()?; + let lane = self.read_lane_index(8)?; + visitor.visit_v128_store16_lane(pos, memarg, lane) + }, + 0x5a => { + let memarg = self.read_memarg()?; + let lane = self.read_lane_index(4)?; + visitor.visit_v128_store32_lane(pos, memarg, lane) + }, + 0x5b => { + let memarg = self.read_memarg()?; + let lane = self.read_lane_index(2)?; + visitor.visit_v128_store64_lane(pos, memarg, lane) + }, + + 0x5c => visitor.visit_v128_load32_zero(pos, self.read_memarg_of_align(2)?), + 0x5d => visitor.visit_v128_load64_zero(pos, self.read_memarg_of_align(3)?), + 0x5e => visitor.visit_f32x4_demote_f64x2_zero(pos), + 0x5f => visitor.visit_f64x2_promote_low_f32x4(pos), + 0x60 => visitor.visit_i8x16_abs(pos), + 0x61 => visitor.visit_i8x16_neg(pos), + 0x62 => visitor.visit_i8x16_popcnt(pos), + 0x63 => visitor.visit_i8x16_all_true(pos), + 0x64 => visitor.visit_i8x16_bitmask(pos), + 0x65 => visitor.visit_i8x16_narrow_i16x8_s(pos), + 0x66 => visitor.visit_i8x16_narrow_i16x8_u(pos), + 0x67 => visitor.visit_f32x4_ceil(pos), + 0x68 => visitor.visit_f32x4_floor(pos), + 0x69 => visitor.visit_f32x4_trunc(pos), + 0x6a => visitor.visit_f32x4_nearest(pos), + 0x6b => visitor.visit_i8x16_shl(pos), + 0x6c => visitor.visit_i8x16_shr_s(pos), + 0x6d => visitor.visit_i8x16_shr_u(pos), + 0x6e => visitor.visit_i8x16_add(pos), + 0x6f => visitor.visit_i8x16_add_sat_s(pos), + 0x70 => visitor.visit_i8x16_add_sat_u(pos), + 0x71 => visitor.visit_i8x16_sub(pos), + 0x72 => visitor.visit_i8x16_sub_sat_s(pos), + 0x73 => visitor.visit_i8x16_sub_sat_u(pos), + 0x74 => visitor.visit_f64x2_ceil(pos), + 0x75 => visitor.visit_f64x2_floor(pos), + 0x76 => visitor.visit_i8x16_min_s(pos), + 0x77 => visitor.visit_i8x16_min_u(pos), + 0x78 => visitor.visit_i8x16_max_s(pos), + 0x79 => visitor.visit_i8x16_max_u(pos), + 0x7a => visitor.visit_f64x2_trunc(pos), + 0x7b => visitor.visit_i8x16_rounding_average_u(pos), + 0x7c => visitor.visit_i16x8_ext_add_pairwise_i8x16_s(pos), + 0x7d => visitor.visit_i16x8_ext_add_pairwise_i8x16_u(pos), + 0x7e => visitor.visit_i32x4_ext_add_pairwise_i16x8_s(pos), + 0x7f => visitor.visit_i32x4_ext_add_pairwise_i16x8_u(pos), + 0x80 => visitor.visit_i16x8_abs(pos), + 0x81 => visitor.visit_i16x8_neg(pos), + 0x82 => visitor.visit_i16x8_q15_mulr_sat_s(pos), + 0x83 => visitor.visit_i16x8_all_true(pos), + 0x84 => visitor.visit_i16x8_bitmask(pos), + 0x85 => visitor.visit_i16x8_narrow_i32x4_s(pos), + 0x86 => visitor.visit_i16x8_narrow_i32x4_u(pos), + 0x87 => visitor.visit_i16x8_extend_low_i8x16_s(pos), + 0x88 => visitor.visit_i16x8_extend_high_i8x16_s(pos), + 0x89 => visitor.visit_i16x8_extend_low_i8x16_u(pos), + 0x8a => visitor.visit_i16x8_extend_high_i8x16_u(pos), + 0x8b => visitor.visit_i16x8_shl(pos), + 0x8c => visitor.visit_i16x8_shr_s(pos), + 0x8d => visitor.visit_i16x8_shr_u(pos), + 0x8e => visitor.visit_i16x8_add(pos), + 0x8f => visitor.visit_i16x8_add_sat_s(pos), + 0x90 => visitor.visit_i16x8_add_sat_u(pos), + 0x91 => visitor.visit_i16x8_sub(pos), + 0x92 => visitor.visit_i16x8_sub_sat_s(pos), + 0x93 => visitor.visit_i16x8_sub_sat_u(pos), + 0x94 => visitor.visit_f64x2_nearest(pos), + 0x95 => visitor.visit_i16x8_mul(pos), + 0x96 => visitor.visit_i16x8_min_s(pos), + 0x97 => visitor.visit_i16x8_min_u(pos), + 0x98 => visitor.visit_i16x8_max_s(pos), + 0x99 => visitor.visit_i16x8_max_u(pos), + 0x9b => visitor.visit_i16x8_rounding_average_u(pos), + 0x9c => visitor.visit_i16x8_ext_mul_low_i8x16_s(pos), + 0x9d => visitor.visit_i16x8_ext_mul_high_i8x16_s(pos), + 0x9e => visitor.visit_i16x8_ext_mul_low_i8x16_u(pos), + 0x9f => visitor.visit_i16x8_ext_mul_high_i8x16_u(pos), + 0xa0 => visitor.visit_i32x4_abs(pos), + 0xa2 => visitor.visit_i8x16_relaxed_swizzle(pos), + 0xa1 => visitor.visit_i32x4_neg(pos), + 0xa3 => visitor.visit_i32x4_all_true(pos), + 0xa4 => visitor.visit_i32x4_bitmask(pos), + 0xa5 => visitor.visit_i32x4_relaxed_trunc_sat_f32x4_s(pos), + 0xa6 => visitor.visit_i32x4_relaxed_trunc_sat_f32x4_u(pos), + 0xa7 => visitor.visit_i32x4_extend_low_i16x8_s(pos), + 0xa8 => visitor.visit_i32x4_extend_high_i16x8_s(pos), + 0xa9 => visitor.visit_i32x4_extend_low_i16x8_u(pos), + 0xaa => visitor.visit_i32x4_extend_high_i16x8_u(pos), + 0xab => visitor.visit_i32x4_shl(pos), + 0xac => visitor.visit_i32x4_shr_s(pos), + 0xad => visitor.visit_i32x4_shr_u(pos), + 0xae => visitor.visit_i32x4_add(pos), + 0xaf => visitor.visit_f32x4_fma(pos), + 0xb0 => visitor.visit_f32x4_fms(pos), + 0xb1 => visitor.visit_i32x4_sub(pos), + 0xb2 => visitor.visit_i8x16_lane_select(pos), + 0xb3 => visitor.visit_i16x8_lane_select(pos), + 0xb4 => visitor.visit_f32x4_relaxed_min(pos), + 0xb5 => visitor.visit_i32x4_mul(pos), + 0xb6 => visitor.visit_i32x4_min_s(pos), + 0xb7 => visitor.visit_i32x4_min_u(pos), + 0xb8 => visitor.visit_i32x4_max_s(pos), + 0xb9 => visitor.visit_i32x4_max_u(pos), + 0xba => visitor.visit_i32x4_dot_i16x8_s(pos), + 0xbc => visitor.visit_i32x4_ext_mul_low_i16x8_s(pos), + 0xbd => visitor.visit_i32x4_ext_mul_high_i16x8_s(pos), + 0xbe => visitor.visit_i32x4_ext_mul_low_i16x8_u(pos), + 0xbf => visitor.visit_i32x4_ext_mul_high_i16x8_u(pos), + 0xc0 => visitor.visit_i64x2_abs(pos), + 0xc1 => visitor.visit_i64x2_neg(pos), + 0xc3 => visitor.visit_i64x2_all_true(pos), + 0xc4 => visitor.visit_i64x2_bitmask(pos), + 0xc5 => visitor.visit_i32x4_relaxed_trunc_sat_f64x2_s_zero(pos), + 0xc6 => visitor.visit_i32x4_relaxed_trunc_sat_f64x2_u_zero(pos), + 0xc7 => visitor.visit_i64x2_extend_low_i32x4_s(pos), + 0xc8 => visitor.visit_i64x2_extend_high_i32x4_s(pos), + 0xc9 => visitor.visit_i64x2_extend_low_i32x4_u(pos), + 0xca => visitor.visit_i64x2_extend_high_i32x4_u(pos), + 0xcb => visitor.visit_i64x2_shl(pos), + 0xcc => visitor.visit_i64x2_shr_s(pos), + 0xcd => visitor.visit_i64x2_shr_u(pos), + 0xce => visitor.visit_i64x2_add(pos), + 0xcf => visitor.visit_f64x2_fma(pos), + 0xd0 => visitor.visit_f64x2_fms(pos), + 0xd1 => visitor.visit_i64x2_sub(pos), + 0xd2 => visitor.visit_i32x4_lane_select(pos), + 0xd3 => visitor.visit_i64x2_lane_select(pos), + 0xd4 => visitor.visit_f64x2_relaxed_min(pos), + 0xd5 => visitor.visit_i64x2_mul(pos), + 0xd6 => visitor.visit_i64x2_eq(pos), + 0xd7 => visitor.visit_i64x2_ne(pos), + 0xd8 => visitor.visit_i64x2_lt_s(pos), + 0xd9 => visitor.visit_i64x2_gt_s(pos), + 0xda => visitor.visit_i64x2_le_s(pos), + 0xdb => visitor.visit_i64x2_ge_s(pos), + 0xdc => visitor.visit_i64x2_ext_mul_low_i32x4_s(pos), + 0xdd => visitor.visit_i64x2_ext_mul_high_i32x4_s(pos), + 0xde => visitor.visit_i64x2_ext_mul_low_i32x4_u(pos), + 0xdf => visitor.visit_i64x2_ext_mul_high_i32x4_u(pos), + 0xe0 => visitor.visit_f32x4_abs(pos), + 0xe1 => visitor.visit_f32x4_neg(pos), + 0xe2 => visitor.visit_f32x4_relaxed_max(pos), + 0xe3 => visitor.visit_f32x4_sqrt(pos), + 0xe4 => visitor.visit_f32x4_add(pos), + 0xe5 => visitor.visit_f32x4_sub(pos), + 0xe6 => visitor.visit_f32x4_mul(pos), + 0xe7 => visitor.visit_f32x4_div(pos), + 0xe8 => visitor.visit_f32x4_min(pos), + 0xe9 => visitor.visit_f32x4_max(pos), + 0xea => visitor.visit_f32x4_p_min(pos), + 0xeb => visitor.visit_f32x4_p_max(pos), + 0xec => visitor.visit_f64x2_abs(pos), + 0xed => visitor.visit_f64x2_neg(pos), + 0xee => visitor.visit_f64x2_relaxed_max(pos), + 0xef => visitor.visit_f64x2_sqrt(pos), + 0xf0 => visitor.visit_f64x2_add(pos), + 0xf1 => visitor.visit_f64x2_sub(pos), + 0xf2 => visitor.visit_f64x2_mul(pos), + 0xf3 => visitor.visit_f64x2_div(pos), + 0xf4 => visitor.visit_f64x2_min(pos), + 0xf5 => visitor.visit_f64x2_max(pos), + 0xf6 => visitor.visit_f64x2_p_min(pos), + 0xf7 => visitor.visit_f64x2_p_max(pos), + 0xf8 => visitor.visit_i32x4_trunc_sat_f32x4_s(pos), + 0xf9 => visitor.visit_i32x4_trunc_sat_f32x4_u(pos), + 0xfa => visitor.visit_f32x4_convert_i32x4_s(pos), + 0xfb => visitor.visit_f32x4_convert_i32x4_u(pos), + 0xfc => visitor.visit_i32x4_trunc_sat_f64x2_s_zero(pos), + 0xfd => visitor.visit_i32x4_trunc_sat_f64x2_u_zero(pos), + 0xfe => visitor.visit_f64x2_convert_low_i32x4_s(pos), + 0xff => visitor.visit_f64x2_convert_low_i32x4_u(pos), + + _ => { + return Err(BinaryReaderError::new( + format!("unknown 0xfd subopcode: 0x{:x}", code), + self.original_position() - 1, + )); + } + }) + } + + fn visit_0xfe_operator( + &mut self, + visitor: &mut T, + ) -> Result<>::Output> + where + T: VisitOperator<'a>, + { + let pos = self.original_position(); + let code = self.read_var_u32()?; + Ok(match code { + 0x00 => visitor.visit_memory_atomic_notify(pos, self.read_memarg_of_align(2)?), + 0x01 => visitor.visit_memory_atomic_wait32(pos, self.read_memarg_of_align(2)?), + 0x02 => visitor.visit_memory_atomic_wait64(pos, self.read_memarg_of_align(3)?), + 0x03 => visitor.visit_atomic_fence(pos, self.read_u8()? as u8), + 0x10 => visitor.visit_i32_atomic_load(pos, self.read_memarg_of_align(2)?), + 0x11 => visitor.visit_i64_atomic_load(pos, self.read_memarg_of_align(3)?), + 0x12 => visitor.visit_i32_atomic_load8_u(pos, self.read_memarg_of_align(0)?), + 0x13 => visitor.visit_i32_atomic_load16_u(pos, self.read_memarg_of_align(1)?), + 0x14 => visitor.visit_i64_atomic_load8_u(pos, self.read_memarg_of_align(0)?), + 0x15 => visitor.visit_i64_atomic_load16_u(pos, self.read_memarg_of_align(1)?), + 0x16 => visitor.visit_i64_atomic_load32_u(pos, self.read_memarg_of_align(2)?), + 0x17 => visitor.visit_i32_atomic_store(pos, self.read_memarg_of_align(2)?), + 0x18 => visitor.visit_i64_atomic_store(pos, self.read_memarg_of_align(3)?), + 0x19 => visitor.visit_i32_atomic_store8(pos, self.read_memarg_of_align(0)?), + 0x1a => visitor.visit_i32_atomic_store16(pos, self.read_memarg_of_align(1)?), + 0x1b => visitor.visit_i64_atomic_store8(pos, self.read_memarg_of_align(0)?), + 0x1c => visitor.visit_i64_atomic_store16(pos, self.read_memarg_of_align(1)?), + 0x1d => visitor.visit_i64_atomic_store32(pos, self.read_memarg_of_align(2)?), + 0x1e => visitor.visit_i32_atomic_rmw_add(pos, self.read_memarg_of_align(2)?), + 0x1f => visitor.visit_i64_atomic_rmw_add(pos, self.read_memarg_of_align(3)?), + 0x20 => visitor.visit_i32_atomic_rmw8_add_u(pos, self.read_memarg_of_align(0)?), + 0x21 => visitor.visit_i32_atomic_rmw16_add_u(pos, self.read_memarg_of_align(1)?), + 0x22 => visitor.visit_i64_atomic_rmw8_add_u(pos, self.read_memarg_of_align(0)?), + 0x23 => visitor.visit_i64_atomic_rmw16_add_u(pos, self.read_memarg_of_align(1)?), + 0x24 => visitor.visit_i64_atomic_rmw32_add_u(pos, self.read_memarg_of_align(2)?), + 0x25 => visitor.visit_i32_atomic_rmw_sub(pos, self.read_memarg_of_align(2)?), + 0x26 => visitor.visit_i64_atomic_rmw_sub(pos, self.read_memarg_of_align(3)?), + 0x27 => visitor.visit_i32_atomic_rmw8_sub_u(pos, self.read_memarg_of_align(0)?), + 0x28 => visitor.visit_i32_atomic_rmw16_sub_u(pos, self.read_memarg_of_align(1)?), + 0x29 => visitor.visit_i64_atomic_rmw8_sub_u(pos, self.read_memarg_of_align(0)?), + 0x2a => visitor.visit_i64_atomic_rmw16_sub_u(pos, self.read_memarg_of_align(1)?), + 0x2b => visitor.visit_i64_atomic_rmw32_sub_u(pos, self.read_memarg_of_align(2)?), + 0x2c => visitor.visit_i32_atomic_rmw_and(pos, self.read_memarg_of_align(2)?), + 0x2d => visitor.visit_i64_atomic_rmw_and(pos, self.read_memarg_of_align(3)?), + 0x2e => visitor.visit_i32_atomic_rmw8_and_u(pos, self.read_memarg_of_align(0)?), + 0x2f => visitor.visit_i32_atomic_rmw16_and_u(pos, self.read_memarg_of_align(1)?), + 0x30 => visitor.visit_i64_atomic_rmw8_and_u(pos, self.read_memarg_of_align(0)?), + 0x31 => visitor.visit_i64_atomic_rmw16_and_u(pos, self.read_memarg_of_align(1)?), + 0x32 => visitor.visit_i64_atomic_rmw32_and_u(pos, self.read_memarg_of_align(2)?), + 0x33 => visitor.visit_i32_atomic_rmw_or(pos, self.read_memarg_of_align(2)?), + 0x34 => visitor.visit_i64_atomic_rmw_or(pos, self.read_memarg_of_align(3)?), + 0x35 => visitor.visit_i32_atomic_rmw8_or_u(pos, self.read_memarg_of_align(0)?), + 0x36 => visitor.visit_i32_atomic_rmw16_or_u(pos, self.read_memarg_of_align(1)?), + 0x37 => visitor.visit_i64_atomic_rmw8_or_u(pos, self.read_memarg_of_align(0)?), + 0x38 => visitor.visit_i64_atomic_rmw16_or_u(pos, self.read_memarg_of_align(1)?), + 0x39 => visitor.visit_i64_atomic_rmw32_or_u(pos, self.read_memarg_of_align(2)?), + 0x3a => visitor.visit_i32_atomic_rmw_xor(pos, self.read_memarg_of_align(2)?), + 0x3b => visitor.visit_i64_atomic_rmw_xor(pos, self.read_memarg_of_align(3)?), + 0x3c => visitor.visit_i32_atomic_rmw8_xor_u(pos, self.read_memarg_of_align(0)?), + 0x3d => visitor.visit_i32_atomic_rmw16_xor_u(pos, self.read_memarg_of_align(1)?), + 0x3e => visitor.visit_i64_atomic_rmw8_xor_u(pos, self.read_memarg_of_align(0)?), + 0x3f => visitor.visit_i64_atomic_rmw16_xor_u(pos, self.read_memarg_of_align(1)?), + 0x40 => visitor.visit_i64_atomic_rmw32_xor_u(pos, self.read_memarg_of_align(2)?), + 0x41 => visitor.visit_i32_atomic_rmw_xchg(pos, self.read_memarg_of_align(2)?), + 0x42 => visitor.visit_i64_atomic_rmw_xchg(pos, self.read_memarg_of_align(3)?), + 0x43 => visitor.visit_i32_atomic_rmw8_xchg_u(pos, self.read_memarg_of_align(0)?), + 0x44 => visitor.visit_i32_atomic_rmw16_xchg_u(pos, self.read_memarg_of_align(1)?), + 0x45 => visitor.visit_i64_atomic_rmw8_xchg_u(pos, self.read_memarg_of_align(0)?), + 0x46 => visitor.visit_i64_atomic_rmw16_xchg_u(pos, self.read_memarg_of_align(1)?), + 0x47 => visitor.visit_i64_atomic_rmw32_xchg_u(pos, self.read_memarg_of_align(2)?), + 0x48 => visitor.visit_i32_atomic_rmw_cmpxchg(pos, self.read_memarg_of_align(2)?), + 0x49 => visitor.visit_i64_atomic_rmw_cmpxchg(pos, self.read_memarg_of_align(3)?), + 0x4a => visitor.visit_i32_atomic_rmw8_cmpxchg_u(pos, self.read_memarg_of_align(0)?), + 0x4b => visitor.visit_i32_atomic_rmw16_cmpxchg_u(pos, self.read_memarg_of_align(1)?), + 0x4c => visitor.visit_i64_atomic_rmw8_cmpxchg_u(pos, self.read_memarg_of_align(0)?), + 0x4d => visitor.visit_i64_atomic_rmw16_cmpxchg_u(pos, self.read_memarg_of_align(1)?), + 0x4e => visitor.visit_i64_atomic_rmw32_cmpxchg_u(pos, self.read_memarg_of_align(2)?), + + _ => { + return Err(BinaryReaderError::new( + format!("unknown 0xfe subopcode: 0x{:x}", code), + self.original_position() - 1, + )); + } + }) + } + + fn visit_0xf1_operator( + &mut self, + visitor: &mut T, + ) -> Result<>::Output> + where + T: VisitOperator<'a>, + { + let pos = self.original_position(); + // let code = self.read_var_u32()?; + let code = self.read_u8()?; + Ok(match code { + 0xee => visitor.visit_memory_read_pkru(pos), + 0xef => visitor.visit_memory_write_pkru(pos), + + _ => { + return Err(BinaryReaderError::new( + format!("unknown 0xf1 subopcode: 0x{:x}", code), + self.original_position() - 1, + )); + } + }) + } + + /// Reads the next available `Operator`. + /// + /// # Errors + /// + /// If `BinaryReader` has less bytes remaining than required to parse + /// the `Operator`. + pub fn read_operator(&mut self) -> Result> { + self.visit_operator(&mut OperatorFactory::new()) + } + + fn read_lane_index(&mut self, max: u8) -> Result { + let index = self.read_u8()?; + if index >= max { + return Err(BinaryReaderError::new( + "invalid lane index", + self.original_position() - 1, + )); + } + Ok(index as SIMDLaneIndex) + } + + fn read_v128(&mut self) -> Result { + let mut bytes = [0; 16]; + bytes.clone_from_slice(self.read_bytes(16)?); + Ok(V128(bytes)) + } + + pub(crate) fn read_header_version(&mut self) -> Result { + let magic_number = self.read_bytes(4)?; + if magic_number != WASM_MAGIC_NUMBER { + return Err(BinaryReaderError::new( + "magic header not detected: bad magic number", + self.original_position() - 4, + )); + } + self.read_u32() + } + + pub(crate) fn read_name_type(&mut self) -> Result { + let code = self.read_u7()?; + match code { + 0 => Ok(NameType::Module), + 1 => Ok(NameType::Function), + 2 => Ok(NameType::Local), + 3 => Ok(NameType::Label), + 4 => Ok(NameType::Type), + 5 => Ok(NameType::Table), + 6 => Ok(NameType::Memory), + 7 => Ok(NameType::Global), + 8 => Ok(NameType::Element), + 9 => Ok(NameType::Data), + _ => Ok(NameType::Unknown(code)), + } + } + + pub(crate) fn read_linking_type(&mut self) -> Result { + let ty = self.read_var_u32()?; + Ok(match ty { + 1 => LinkingType::StackPointer(self.read_var_u32()?), + _ => { + return Err(BinaryReaderError::new( + "invalid linking type", + self.original_position() - 1, + )); + } + }) + } + + pub(crate) fn read_reloc_type(&mut self) -> Result { + let code = self.read_u7()?; + match code { + 0 => Ok(RelocType::FunctionIndexLEB), + 1 => Ok(RelocType::TableIndexSLEB), + 2 => Ok(RelocType::TableIndexI32), + 3 => Ok(RelocType::GlobalAddrLEB), + 4 => Ok(RelocType::GlobalAddrSLEB), + 5 => Ok(RelocType::GlobalAddrI32), + 6 => Ok(RelocType::TypeIndexLEB), + 7 => Ok(RelocType::GlobalIndexLEB), + _ => Err(BinaryReaderError::new( + "invalid reloc type", + self.original_position() - 1, + )), + } + } + + pub(crate) fn read_const_expr(&mut self) -> Result> { + let expr_offset = self.position; + self.skip_const_expr()?; + let data = &self.buffer[expr_offset..self.position]; + Ok(ConstExpr::new(data, self.original_offset + expr_offset)) + } + + pub(crate) fn skip_const_expr(&mut self) -> Result<()> { + // TODO add skip_operator() method and/or validate ConstExpr operators. + loop { + if let Operator::End = self.read_operator()? { + return Ok(()); + } + } + } +} + +impl<'a> BrTable<'a> { + /// Returns the number of `br_table` entries, not including the default + /// label + pub fn len(&self) -> u32 { + self.cnt + } + + /// Returns whether `BrTable` doesn't have any labels apart from the default one. + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Returns the default target of this `br_table` instruction. + pub fn default(&self) -> u32 { + self.default + } + + /// Returns the list of targets that this `br_table` instruction will be + /// jumping to. + /// + /// This method will return an iterator which parses each target of this + /// `br_table` except the default target. The returned iterator will + /// yield `self.len()` elements. + /// + /// # Examples + /// + /// ```rust + /// let buf = [0x0e, 0x02, 0x01, 0x02, 0x00]; + /// let mut reader = wasmparser::BinaryReader::new(&buf); + /// let op = reader.read_operator().unwrap(); + /// if let wasmparser::Operator::BrTable { table } = op { + /// let targets = table.targets().collect::, _>>().unwrap(); + /// assert_eq!(targets, [1, 2]); + /// } + /// ``` + pub fn targets(&self) -> BrTableTargets { + BrTableTargets { + reader: self.reader.clone(), + remaining: self.cnt, + } + } +} + +/// An iterator over the targets of a [`BrTable`]. +/// +/// # Note +/// +/// This iterator parses each target of the underlying `br_table` +/// except for the default target. +/// The iterator will yield exactly as many targets as the `br_table` has. +pub struct BrTableTargets<'a> { + reader: crate::BinaryReader<'a>, + remaining: u32, +} + +impl<'a> Iterator for BrTableTargets<'a> { + type Item = Result; + + fn size_hint(&self) -> (usize, Option) { + let remaining = usize::try_from(self.remaining).unwrap_or_else(|error| { + panic!("could not convert remaining `u32` into `usize`: {}", error) + }); + (remaining, Some(remaining)) + } + + fn next(&mut self) -> Option { + if self.remaining == 0 { + if !self.reader.eof() { + return Some(Err(BinaryReaderError::new( + "trailing data in br_table", + self.reader.original_position(), + ))); + } + return None; + } + self.remaining -= 1; + Some(self.reader.read_var_u32()) + } +} + +impl fmt::Debug for BrTable<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let mut f = f.debug_struct("BrTable"); + f.field("count", &self.cnt); + f.field("default", &self.default); + match self.targets().collect::>>() { + Ok(targets) => { + f.field("targets", &targets); + } + Err(_) => { + f.field("reader", &self.reader); + } + } + f.finish() + } +} + +/// A factory to construct [`Operator`] instances via the [`VisitOperator`] trait. +struct OperatorFactory<'a> { + marker: core::marker::PhantomData &'a ()>, +} + +impl<'a> OperatorFactory<'a> { + /// Creates a new [`OperatorFactory`]. + fn new() -> Self { + Self { + marker: core::marker::PhantomData, + } + } +} + +#[rustfmt::skip] +impl<'a> VisitOperator<'a> for OperatorFactory<'a> { + type Output = Operator<'a>; + + fn visit_nop(&mut self, _offset: usize) -> Self::Output { Operator::Nop } + fn visit_unreachable(&mut self, _offset: usize) -> Self::Output { Operator::Unreachable } + fn visit_block(&mut self, _offset: usize, ty: BlockType) -> Self::Output { Operator::Block { ty } } + fn visit_loop(&mut self, _offset: usize, ty: BlockType) -> Self::Output { Operator::Loop { ty } } + fn visit_if(&mut self, _offset: usize, ty: BlockType) -> Self::Output { Operator::If { ty } } + fn visit_else(&mut self, _offset: usize) -> Self::Output { Operator::Else } + fn visit_try(&mut self, _offset: usize, ty: BlockType) -> Self::Output { Operator::Try { ty } } + fn visit_catch(&mut self, _offset: usize, index: u32) -> Self::Output { Operator::Catch { index } } + fn visit_throw(&mut self, _offset: usize, index: u32) -> Self::Output { Operator::Throw { index } } + fn visit_rethrow(&mut self, _offset: usize, relative_depth: u32) -> Self::Output { Operator::Rethrow { relative_depth } } + fn visit_delegate(&mut self, _offset: usize, relative_depth: u32) -> Self::Output { Operator::Delegate { relative_depth } } + fn visit_catch_all(&mut self, _offset: usize) -> Self::Output { Operator::CatchAll } + fn visit_end(&mut self, _offset: usize) -> Self::Output { Operator::End } + fn visit_br(&mut self, _offset: usize, relative_depth: u32) -> Self::Output { Operator::Br { relative_depth } } + fn visit_br_if(&mut self, _offset: usize, relative_depth: u32) -> Self::Output { Operator::BrIf { relative_depth } } + fn visit_br_table(&mut self, _offset: usize, table: &BrTable<'a>) -> Self::Output { Operator::BrTable { table: table.clone() } } + fn visit_return(&mut self, _offset: usize) -> Self::Output { Operator::Return } + fn visit_call(&mut self, _offset: usize, function_index: u32) -> Self::Output { Operator::Call { function_index } } + fn visit_return_call(&mut self, _offset: usize, function_index: u32) -> Self::Output { Operator::ReturnCall { function_index } } + fn visit_call_indirect(&mut self, _offset: usize, index: u32, table_index: u32, table_byte: u8) -> Self::Output { Operator::CallIndirect { index, table_index, table_byte } } + fn visit_return_call_indirect(&mut self, _offset: usize, index: u32, table_index: u32) -> Self::Output { Operator::ReturnCallIndirect { index, table_index } } + fn visit_drop(&mut self, _offset: usize) -> Self::Output { Operator::Drop } + fn visit_select(&mut self, _offset: usize) -> Self::Output { Operator::Select } + fn visit_typed_select(&mut self, _offset: usize, ty: ValType) -> Self::Output { Operator::TypedSelect { ty } } + fn visit_local_get(&mut self, _offset: usize, local_index: u32) -> Self::Output { Operator::LocalGet { local_index } } + fn visit_local_set(&mut self, _offset: usize, local_index: u32) -> Self::Output { Operator::LocalSet { local_index } } + fn visit_local_tee(&mut self, _offset: usize, local_index: u32) -> Self::Output { Operator::LocalTee { local_index } } + fn visit_global_get(&mut self, _offset: usize, global_index: u32) -> Self::Output { Operator::GlobalGet { global_index } } + fn visit_global_set(&mut self, _offset: usize, global_index: u32) -> Self::Output { Operator::GlobalSet { global_index } } + fn visit_i32_load(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32Load { memarg } } + fn visit_i64_load(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64Load { memarg } } + fn visit_f32_load(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::F32Load { memarg } } + fn visit_f64_load(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::F64Load { memarg } } + fn visit_i32_load8_s(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32Load8S { memarg } } + fn visit_i32_load8_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32Load8U { memarg } } + fn visit_i32_load16_s(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32Load16S { memarg } } + fn visit_i32_load16_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32Load16U { memarg } } + fn visit_i64_load8_s(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64Load8S { memarg } } + fn visit_i64_load8_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64Load8U { memarg } } + fn visit_i64_load16_s(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64Load16S { memarg } } + fn visit_i64_load16_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64Load16U { memarg } } + fn visit_i64_load32_s(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64Load32S { memarg } } + fn visit_i64_load32_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64Load32U { memarg } } + fn visit_i32_store(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32Store { memarg } } + fn visit_i64_store(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64Store { memarg } } + fn visit_f32_store(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::F32Store { memarg } } + fn visit_f64_store(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::F64Store { memarg } } + fn visit_i32_store8(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32Store8 { memarg } } + fn visit_i32_store16(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32Store16 { memarg } } + fn visit_i64_store8(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64Store8 { memarg } } + fn visit_i64_store16(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64Store16 { memarg } } + fn visit_i64_store32(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64Store32 { memarg } } + fn visit_memory_size(&mut self, _offset: usize, mem: u32, mem_byte: u8) -> Self::Output { Operator::MemorySize { mem, mem_byte } } + fn visit_memory_grow(&mut self, _offset: usize, mem: u32, mem_byte: u8) -> Self::Output { Operator::MemoryGrow { mem, mem_byte } } + fn visit_i32_const(&mut self, _offset: usize, value: i32) -> Self::Output { Operator::I32Const { value } } + fn visit_i64_const(&mut self, _offset: usize, value: i64) -> Self::Output { Operator::I64Const { value } } + fn visit_f32_const(&mut self, _offset: usize, value: Ieee32) -> Self::Output { Operator::F32Const { value } } + fn visit_f64_const(&mut self, _offset: usize, value: Ieee64) -> Self::Output { Operator::F64Const { value } } + fn visit_i32_eqz(&mut self, _offset: usize) -> Self::Output { Operator::I32Eqz } + fn visit_i32_eq(&mut self, _offset: usize) -> Self::Output { Operator::I32Eq } + fn visit_i32_ne(&mut self, _offset: usize) -> Self::Output { Operator::I32Ne } + fn visit_i32_lt_s(&mut self, _offset: usize) -> Self::Output { Operator::I32LtS } + fn visit_i32_lt_u(&mut self, _offset: usize) -> Self::Output { Operator::I32LtU } + fn visit_i32_gt_s(&mut self, _offset: usize) -> Self::Output { Operator::I32GtS } + fn visit_i32_gt_u(&mut self, _offset: usize) -> Self::Output { Operator::I32GtU } + fn visit_i32_le_s(&mut self, _offset: usize) -> Self::Output { Operator::I32LeS } + fn visit_i32_le_u(&mut self, _offset: usize) -> Self::Output { Operator::I32LeU } + fn visit_i32_ge_s(&mut self, _offset: usize) -> Self::Output { Operator::I32GeS } + fn visit_i32_ge_u(&mut self, _offset: usize) -> Self::Output { Operator::I32GeU } + fn visit_i64_eqz(&mut self, _offset: usize) -> Self::Output { Operator::I64Eqz } + fn visit_i64_eq(&mut self, _offset: usize) -> Self::Output { Operator::I64Eq } + fn visit_i64_ne(&mut self, _offset: usize) -> Self::Output { Operator::I64Ne } + fn visit_i64_lt_s(&mut self, _offset: usize) -> Self::Output { Operator::I64LtS } + fn visit_i64_lt_u(&mut self, _offset: usize) -> Self::Output { Operator::I64LtU } + fn visit_i64_gt_s(&mut self, _offset: usize) -> Self::Output { Operator::I64GtS } + fn visit_i64_gt_u(&mut self, _offset: usize) -> Self::Output { Operator::I64GtU } + fn visit_i64_le_s(&mut self, _offset: usize) -> Self::Output { Operator::I64LeS } + fn visit_i64_le_u(&mut self, _offset: usize) -> Self::Output { Operator::I64LeU } + fn visit_i64_ge_s(&mut self, _offset: usize) -> Self::Output { Operator::I64GeS } + fn visit_i64_ge_u(&mut self, _offset: usize) -> Self::Output { Operator::I64GeU } + fn visit_f32_eq(&mut self, _offset: usize) -> Self::Output { Operator::F32Eq } + fn visit_f32_ne(&mut self, _offset: usize) -> Self::Output { Operator::F32Ne } + fn visit_f32_lt(&mut self, _offset: usize) -> Self::Output { Operator::F32Lt } + fn visit_f32_gt(&mut self, _offset: usize) -> Self::Output { Operator::F32Gt } + fn visit_f32_le(&mut self, _offset: usize) -> Self::Output { Operator::F32Le } + fn visit_f32_ge(&mut self, _offset: usize) -> Self::Output { Operator::F32Ge } + fn visit_f64_eq(&mut self, _offset: usize) -> Self::Output { Operator::F64Eq } + fn visit_f64_ne(&mut self, _offset: usize) -> Self::Output { Operator::F64Ne } + fn visit_f64_lt(&mut self, _offset: usize) -> Self::Output { Operator::F64Lt } + fn visit_f64_gt(&mut self, _offset: usize) -> Self::Output { Operator::F64Gt } + fn visit_f64_le(&mut self, _offset: usize) -> Self::Output { Operator::F64Le } + fn visit_f64_ge(&mut self, _offset: usize) -> Self::Output { Operator::F64Ge } + fn visit_i32_clz(&mut self, _offset: usize) -> Self::Output { Operator::I32Clz } + fn visit_i32_ctz(&mut self, _offset: usize) -> Self::Output { Operator::I32Ctz } + fn visit_i32_popcnt(&mut self, _offset: usize) -> Self::Output { Operator::I32Popcnt } + fn visit_i32_add(&mut self, _offset: usize) -> Self::Output { Operator::I32Add } + fn visit_i32_sub(&mut self, _offset: usize) -> Self::Output { Operator::I32Sub } + fn visit_i32_mul(&mut self, _offset: usize) -> Self::Output { Operator::I32Mul } + fn visit_i32_div_s(&mut self, _offset: usize) -> Self::Output { Operator::I32DivS } + fn visit_i32_div_u(&mut self, _offset: usize) -> Self::Output { Operator::I32DivU } + fn visit_i32_rem_s(&mut self, _offset: usize) -> Self::Output { Operator::I32RemS } + fn visit_i32_rem_u(&mut self, _offset: usize) -> Self::Output { Operator::I32RemU } + fn visit_i32_and(&mut self, _offset: usize) -> Self::Output { Operator::I32And } + fn visit_i32_or(&mut self, _offset: usize) -> Self::Output { Operator::I32Or } + fn visit_i32_xor(&mut self, _offset: usize) -> Self::Output { Operator::I32Xor } + fn visit_i32_shl(&mut self, _offset: usize) -> Self::Output { Operator::I32Shl } + fn visit_i32_shr_s(&mut self, _offset: usize) -> Self::Output { Operator::I32ShrS } + fn visit_i32_shr_u(&mut self, _offset: usize) -> Self::Output { Operator::I32ShrU } + fn visit_i32_rotl(&mut self, _offset: usize) -> Self::Output { Operator::I32Rotl } + fn visit_i32_rotr(&mut self, _offset: usize) -> Self::Output { Operator::I32Rotr } + fn visit_i64_clz(&mut self, _offset: usize) -> Self::Output { Operator::I64Clz } + fn visit_i64_ctz(&mut self, _offset: usize) -> Self::Output { Operator::I64Ctz } + fn visit_i64_popcnt(&mut self, _offset: usize) -> Self::Output { Operator::I64Popcnt } + fn visit_i64_add(&mut self, _offset: usize) -> Self::Output { Operator::I64Add } + fn visit_i64_sub(&mut self, _offset: usize) -> Self::Output { Operator::I64Sub } + fn visit_i64_mul(&mut self, _offset: usize) -> Self::Output { Operator::I64Mul } + fn visit_i64_div_s(&mut self, _offset: usize) -> Self::Output { Operator::I64DivS } + fn visit_i64_div_u(&mut self, _offset: usize) -> Self::Output { Operator::I64DivU } + fn visit_i64_rem_s(&mut self, _offset: usize) -> Self::Output { Operator::I64RemS } + fn visit_i64_rem_u(&mut self, _offset: usize) -> Self::Output { Operator::I64RemU } + fn visit_i64_and(&mut self, _offset: usize) -> Self::Output { Operator::I64And } + fn visit_i64_or(&mut self, _offset: usize) -> Self::Output { Operator::I64Or } + fn visit_i64_xor(&mut self, _offset: usize) -> Self::Output { Operator::I64Xor } + fn visit_i64_shl(&mut self, _offset: usize) -> Self::Output { Operator::I64Shl } + fn visit_i64_shr_s(&mut self, _offset: usize) -> Self::Output { Operator::I64ShrS } + fn visit_i64_shr_u(&mut self, _offset: usize) -> Self::Output { Operator::I64ShrU } + fn visit_i64_rotl(&mut self, _offset: usize) -> Self::Output { Operator::I64Rotl } + fn visit_i64_rotr(&mut self, _offset: usize) -> Self::Output { Operator::I64Rotr } + fn visit_f32_abs(&mut self, _offset: usize) -> Self::Output { Operator::F32Abs } + fn visit_f32_neg(&mut self, _offset: usize) -> Self::Output { Operator::F32Neg } + fn visit_f32_ceil(&mut self, _offset: usize) -> Self::Output { Operator::F32Ceil } + fn visit_f32_floor(&mut self, _offset: usize) -> Self::Output { Operator::F32Floor } + fn visit_f32_trunc(&mut self, _offset: usize) -> Self::Output { Operator::F32Trunc } + fn visit_f32_nearest(&mut self, _offset: usize) -> Self::Output { Operator::F32Nearest } + fn visit_f32_sqrt(&mut self, _offset: usize) -> Self::Output { Operator::F32Sqrt } + fn visit_f32_add(&mut self, _offset: usize) -> Self::Output { Operator::F32Add } + fn visit_f32_sub(&mut self, _offset: usize) -> Self::Output { Operator::F32Sub } + fn visit_f32_mul(&mut self, _offset: usize) -> Self::Output { Operator::F32Mul } + fn visit_f32_div(&mut self, _offset: usize) -> Self::Output { Operator::F32Div } + fn visit_f32_min(&mut self, _offset: usize) -> Self::Output { Operator::F32Min } + fn visit_f32_max(&mut self, _offset: usize) -> Self::Output { Operator::F32Max } + fn visit_f32_copysign(&mut self, _offset: usize) -> Self::Output { Operator::F32Copysign } + fn visit_f64_abs(&mut self, _offset: usize) -> Self::Output { Operator::F64Abs } + fn visit_f64_neg(&mut self, _offset: usize) -> Self::Output { Operator::F64Neg } + fn visit_f64_ceil(&mut self, _offset: usize) -> Self::Output { Operator::F64Ceil } + fn visit_f64_floor(&mut self, _offset: usize) -> Self::Output { Operator::F64Floor } + fn visit_f64_trunc(&mut self, _offset: usize) -> Self::Output { Operator::F64Trunc } + fn visit_f64_nearest(&mut self, _offset: usize) -> Self::Output { Operator::F64Nearest } + fn visit_f64_sqrt(&mut self, _offset: usize) -> Self::Output { Operator::F64Sqrt } + fn visit_f64_add(&mut self, _offset: usize) -> Self::Output { Operator::F64Add } + fn visit_f64_sub(&mut self, _offset: usize) -> Self::Output { Operator::F64Sub } + fn visit_f64_mul(&mut self, _offset: usize) -> Self::Output { Operator::F64Mul } + fn visit_f64_div(&mut self, _offset: usize) -> Self::Output { Operator::F64Div } + fn visit_f64_min(&mut self, _offset: usize) -> Self::Output { Operator::F64Min } + fn visit_f64_max(&mut self, _offset: usize) -> Self::Output { Operator::F64Max } + fn visit_f64_copysign(&mut self, _offset: usize) -> Self::Output { Operator::F64Copysign } + fn visit_i32_wrap_i64(&mut self, _offset: usize) -> Self::Output { Operator::I32WrapI64 } + fn visit_i32_trunc_f32s(&mut self, _offset: usize) -> Self::Output { Operator::I32TruncF32S } + fn visit_i32_trunc_f32u(&mut self, _offset: usize) -> Self::Output { Operator::I32TruncF32U } + fn visit_i32_trunc_f64s(&mut self, _offset: usize) -> Self::Output { Operator::I32TruncF64S } + fn visit_i32_trunc_f64u(&mut self, _offset: usize) -> Self::Output { Operator::I32TruncF64U } + fn visit_i64_extend_i32s(&mut self, _offset: usize) -> Self::Output { Operator::I64ExtendI32S } + fn visit_i64_extend_i32u(&mut self, _offset: usize) -> Self::Output { Operator::I64ExtendI32U } + fn visit_i64_trunc_f32s(&mut self, _offset: usize) -> Self::Output { Operator::I64TruncF32S } + fn visit_i64_trunc_f32u(&mut self, _offset: usize) -> Self::Output { Operator::I64TruncF32U } + fn visit_i64_trunc_f64s(&mut self, _offset: usize) -> Self::Output { Operator::I64TruncF64S } + fn visit_i64_trunc_f64u(&mut self, _offset: usize) -> Self::Output { Operator::I64TruncF64U } + fn visit_f32_convert_i32s(&mut self, _offset: usize) -> Self::Output { Operator::F32ConvertI32S } + fn visit_f32_convert_i32u(&mut self, _offset: usize) -> Self::Output { Operator::F32ConvertI32U } + fn visit_f32_convert_i64s(&mut self, _offset: usize) -> Self::Output { Operator::F32ConvertI64S } + fn visit_f32_convert_i64u(&mut self, _offset: usize) -> Self::Output { Operator::F32ConvertI64U } + fn visit_f32_demote_f64(&mut self, _offset: usize) -> Self::Output { Operator::F32DemoteF64 } + fn visit_f64_convert_i32s(&mut self, _offset: usize) -> Self::Output { Operator::F64ConvertI32S } + fn visit_f64_convert_i32u(&mut self, _offset: usize) -> Self::Output { Operator::F64ConvertI32U } + fn visit_f64_convert_i64s(&mut self, _offset: usize) -> Self::Output { Operator::F64ConvertI64S } + fn visit_f64_convert_i64u(&mut self, _offset: usize) -> Self::Output { Operator::F64ConvertI64U } + fn visit_f64_promote_f32(&mut self, _offset: usize) -> Self::Output { Operator::F64PromoteF32 } + fn visit_i32_reinterpret_f32(&mut self, _offset: usize) -> Self::Output { Operator::I32ReinterpretF32 } + fn visit_i64_reinterpret_f64(&mut self, _offset: usize) -> Self::Output { Operator::I64ReinterpretF64 } + fn visit_f32_reinterpret_i32(&mut self, _offset: usize) -> Self::Output { Operator::F32ReinterpretI32 } + fn visit_f64_reinterpret_i64(&mut self, _offset: usize) -> Self::Output { Operator::F64ReinterpretI64 } + fn visit_i32_trunc_sat_f32s(&mut self, _offset: usize) -> Self::Output { Operator::I32TruncSatF32S } + fn visit_i32_trunc_sat_f32u(&mut self, _offset: usize) -> Self::Output { Operator::I32TruncSatF32U } + fn visit_i32_trunc_sat_f64s(&mut self, _offset: usize) -> Self::Output { Operator::I32TruncSatF64S } + fn visit_i32_trunc_sat_f64u(&mut self, _offset: usize) -> Self::Output { Operator::I32TruncSatF64U } + fn visit_i64_trunc_sat_f32s(&mut self, _offset: usize) -> Self::Output { Operator::I64TruncSatF32S } + fn visit_i64_trunc_sat_f32u(&mut self, _offset: usize) -> Self::Output { Operator::I64TruncSatF32U } + fn visit_i64_trunc_sat_f64s(&mut self, _offset: usize) -> Self::Output { Operator::I64TruncSatF64S } + fn visit_i64_trunc_sat_f64u(&mut self, _offset: usize) -> Self::Output { Operator::I64TruncSatF64U } + fn visit_i32_extend8_s(&mut self, _offset: usize) -> Self::Output { Operator::I32Extend8S } + fn visit_i32_extend16_s(&mut self, _offset: usize) -> Self::Output { Operator::I32Extend16S } + fn visit_i64_extend8_s(&mut self, _offset: usize) -> Self::Output { Operator::I64Extend8S } + fn visit_i64_extend16_s(&mut self, _offset: usize) -> Self::Output { Operator::I64Extend16S } + fn visit_i64_extend32_s(&mut self, _offset: usize) -> Self::Output { Operator::I64Extend32S } + fn visit_i32_atomic_load(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicLoad { memarg } } + fn visit_i32_atomic_load16_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicLoad16U { memarg } } + fn visit_i32_atomic_load8_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicLoad8U { memarg } } + fn visit_i64_atomic_load(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicLoad { memarg } } + fn visit_i64_atomic_load32_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicLoad32U { memarg } } + fn visit_i64_atomic_load16_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicLoad16U { memarg } } + fn visit_i64_atomic_load8_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicLoad8U { memarg } } + fn visit_i32_atomic_store(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicStore { memarg } } + fn visit_i32_atomic_store16(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicStore16 { memarg } } + fn visit_i32_atomic_store8(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicStore8 { memarg } } + fn visit_i64_atomic_store(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicStore { memarg } } + fn visit_i64_atomic_store32(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicStore32 { memarg } } + fn visit_i64_atomic_store16(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicStore16 { memarg } } + fn visit_i64_atomic_store8(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicStore8 { memarg } } + fn visit_i32_atomic_rmw_add(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmwAdd { memarg } } + fn visit_i32_atomic_rmw_sub(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmwSub { memarg } } + fn visit_i32_atomic_rmw_and(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmwAnd { memarg } } + fn visit_i32_atomic_rmw_or(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmwOr { memarg } } + fn visit_i32_atomic_rmw_xor(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmwXor { memarg } } + fn visit_i32_atomic_rmw16_add_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmw16AddU { memarg } } + fn visit_i32_atomic_rmw16_sub_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmw16SubU { memarg } } + fn visit_i32_atomic_rmw16_and_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmw16AndU { memarg } } + fn visit_i32_atomic_rmw16_or_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmw16OrU { memarg } } + fn visit_i32_atomic_rmw16_xor_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmw16XorU { memarg } } + fn visit_i32_atomic_rmw8_add_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmw8AddU { memarg } } + fn visit_i32_atomic_rmw8_sub_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmw8SubU { memarg } } + fn visit_i32_atomic_rmw8_and_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmw8AndU { memarg } } + fn visit_i32_atomic_rmw8_or_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmw8OrU { memarg } } + fn visit_i32_atomic_rmw8_xor_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmw8XorU { memarg } } + fn visit_i64_atomic_rmw_add(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmwAdd { memarg } } + fn visit_i64_atomic_rmw_sub(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmwSub { memarg } } + fn visit_i64_atomic_rmw_and(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmwAnd { memarg } } + fn visit_i64_atomic_rmw_or(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmwOr { memarg } } + fn visit_i64_atomic_rmw_xor(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmwXor { memarg } } + fn visit_i64_atomic_rmw32_add_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw32AddU { memarg } } + fn visit_i64_atomic_rmw32_sub_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw32SubU { memarg } } + fn visit_i64_atomic_rmw32_and_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw32AndU { memarg } } + fn visit_i64_atomic_rmw32_or_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw32OrU { memarg } } + fn visit_i64_atomic_rmw32_xor_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw32XorU { memarg } } + fn visit_i64_atomic_rmw16_add_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw16AddU { memarg } } + fn visit_i64_atomic_rmw16_sub_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw16SubU { memarg } } + fn visit_i64_atomic_rmw16_and_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw16AndU { memarg } } + fn visit_i64_atomic_rmw16_or_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw16OrU { memarg } } + fn visit_i64_atomic_rmw16_xor_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw16XorU { memarg } } + fn visit_i64_atomic_rmw8_add_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw8AddU { memarg } } + fn visit_i64_atomic_rmw8_sub_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw8SubU { memarg } } + fn visit_i64_atomic_rmw8_and_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw8AndU { memarg } } + fn visit_i64_atomic_rmw8_or_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw8OrU { memarg } } + fn visit_i64_atomic_rmw8_xor_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw8XorU { memarg } } + fn visit_i32_atomic_rmw_xchg(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmwXchg { memarg } } + fn visit_i32_atomic_rmw16_xchg_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmw16XchgU { memarg } } + fn visit_i32_atomic_rmw8_xchg_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmw8XchgU { memarg } } + fn visit_i32_atomic_rmw_cmpxchg(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmwCmpxchg { memarg } } + fn visit_i32_atomic_rmw16_cmpxchg_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmw16CmpxchgU { memarg } } + fn visit_i32_atomic_rmw8_cmpxchg_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I32AtomicRmw8CmpxchgU { memarg } } + fn visit_i64_atomic_rmw_xchg(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmwXchg { memarg } } + fn visit_i64_atomic_rmw32_xchg_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw32XchgU { memarg } } + fn visit_i64_atomic_rmw16_xchg_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw16XchgU { memarg } } + fn visit_i64_atomic_rmw8_xchg_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw8XchgU { memarg } } + fn visit_i64_atomic_rmw_cmpxchg(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmwCmpxchg { memarg } } + fn visit_i64_atomic_rmw32_cmpxchg_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw32CmpxchgU { memarg } } + fn visit_i64_atomic_rmw16_cmpxchg_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw16CmpxchgU { memarg } } + fn visit_i64_atomic_rmw8_cmpxchg_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::I64AtomicRmw8CmpxchgU { memarg } } + fn visit_memory_atomic_notify(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::MemoryAtomicNotify { memarg } } + fn visit_memory_atomic_wait32(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::MemoryAtomicWait32 { memarg } } + fn visit_memory_atomic_wait64(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::MemoryAtomicWait64 { memarg } } + fn visit_atomic_fence(&mut self, _offset: usize, flags: u8) -> Self::Output { Operator::AtomicFence { flags } } + fn visit_ref_null(&mut self, _offset: usize, ty: ValType) -> Self::Output { Operator::RefNull { ty } } + fn visit_ref_is_null(&mut self, _offset: usize) -> Self::Output { Operator::RefIsNull } + fn visit_ref_func(&mut self, _offset: usize, function_index: u32) -> Self::Output { Operator::RefFunc { function_index } } + fn visit_v128_load(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::V128Load { memarg } } + fn visit_v128_store(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::V128Store { memarg } } + fn visit_v128_const(&mut self, _offset: usize, value: V128) -> Self::Output { Operator::V128Const { value } } + fn visit_i8x16_splat(&mut self, _offset: usize) -> Self::Output { Operator::I8x16Splat } + fn visit_i16x8_splat(&mut self, _offset: usize) -> Self::Output { Operator::I16x8Splat } + fn visit_i32x4_splat(&mut self, _offset: usize) -> Self::Output { Operator::I32x4Splat } + fn visit_i64x2_splat(&mut self, _offset: usize) -> Self::Output { Operator::I64x2Splat } + fn visit_f32x4_splat(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Splat } + fn visit_f64x2_splat(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Splat } + fn visit_i8x16_extract_lane_s(&mut self, _offset: usize, lane: SIMDLaneIndex) -> Self::Output { Operator::I8x16ExtractLaneS { lane } } + fn visit_i8x16_extract_lane_u(&mut self, _offset: usize, lane: SIMDLaneIndex) -> Self::Output { Operator::I8x16ExtractLaneU { lane } } + fn visit_i16x8_extract_lane_s(&mut self, _offset: usize, lane: SIMDLaneIndex) -> Self::Output { Operator::I16x8ExtractLaneS { lane } } + fn visit_i16x8_extract_lane_u(&mut self, _offset: usize, lane: SIMDLaneIndex) -> Self::Output { Operator::I16x8ExtractLaneU { lane } } + fn visit_i32x4_extract_lane(&mut self, _offset: usize, lane: SIMDLaneIndex) -> Self::Output { Operator::I32x4ExtractLane { lane } } + fn visit_i8x16_replace_lane(&mut self, _offset: usize, lane: SIMDLaneIndex) -> Self::Output { Operator::I8x16ReplaceLane { lane } } + fn visit_i16x8_replace_lane(&mut self, _offset: usize, lane: SIMDLaneIndex) -> Self::Output { Operator::I16x8ReplaceLane { lane } } + fn visit_i32x4_replace_lane(&mut self, _offset: usize, lane: SIMDLaneIndex) -> Self::Output { Operator::I32x4ReplaceLane { lane } } + fn visit_i64x2_extract_lane(&mut self, _offset: usize, lane: SIMDLaneIndex) -> Self::Output { Operator::I64x2ExtractLane { lane } } + fn visit_i64x2_replace_lane(&mut self, _offset: usize, lane: SIMDLaneIndex) -> Self::Output { Operator::I64x2ReplaceLane { lane } } + fn visit_f32x4_extract_lane(&mut self, _offset: usize, lane: SIMDLaneIndex) -> Self::Output { Operator::F32x4ExtractLane { lane } } + fn visit_f32x4_replace_lane(&mut self, _offset: usize, lane: SIMDLaneIndex) -> Self::Output { Operator::F32x4ReplaceLane { lane } } + fn visit_f64x2_extract_lane(&mut self, _offset: usize, lane: SIMDLaneIndex) -> Self::Output { Operator::F64x2ExtractLane { lane } } + fn visit_f64x2_replace_lane(&mut self, _offset: usize, lane: SIMDLaneIndex) -> Self::Output { Operator::F64x2ReplaceLane { lane } } + fn visit_f32x4_eq(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Eq } + fn visit_f32x4_ne(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Ne } + fn visit_f32x4_lt(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Lt } + fn visit_f32x4_gt(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Gt } + fn visit_f32x4_le(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Le } + fn visit_f32x4_ge(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Ge } + fn visit_f64x2_eq(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Eq } + fn visit_f64x2_ne(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Ne } + fn visit_f64x2_lt(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Lt } + fn visit_f64x2_gt(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Gt } + fn visit_f64x2_le(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Le } + fn visit_f64x2_ge(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Ge } + fn visit_f32x4_add(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Add } + fn visit_f32x4_sub(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Sub } + fn visit_f32x4_mul(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Mul } + fn visit_f32x4_div(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Div } + fn visit_f32x4_min(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Min } + fn visit_f32x4_max(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Max } + fn visit_f32x4_p_min(&mut self, _offset: usize) -> Self::Output { Operator::F32x4PMin } + fn visit_f32x4_p_max(&mut self, _offset: usize) -> Self::Output { Operator::F32x4PMax } + fn visit_f64x2_add(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Add } + fn visit_f64x2_sub(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Sub } + fn visit_f64x2_mul(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Mul } + fn visit_f64x2_div(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Div } + fn visit_f64x2_min(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Min } + fn visit_f64x2_max(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Max } + fn visit_f64x2_p_min(&mut self, _offset: usize) -> Self::Output { Operator::F64x2PMin } + fn visit_f64x2_p_max(&mut self, _offset: usize) -> Self::Output { Operator::F64x2PMax } + fn visit_f32x4_relaxed_min(&mut self, _offset: usize) -> Self::Output { Operator::F32x4RelaxedMin } + fn visit_f32x4_relaxed_max(&mut self, _offset: usize) -> Self::Output { Operator::F32x4RelaxedMax } + fn visit_f64x2_relaxed_min(&mut self, _offset: usize) -> Self::Output { Operator::F64x2RelaxedMin } + fn visit_f64x2_relaxed_max(&mut self, _offset: usize) -> Self::Output { Operator::F64x2RelaxedMax } + fn visit_i8x16_eq(&mut self, _offset: usize) -> Self::Output { Operator::I8x16Eq } + fn visit_i8x16_ne(&mut self, _offset: usize) -> Self::Output { Operator::I8x16Ne } + fn visit_i8x16_lt_s(&mut self, _offset: usize) -> Self::Output { Operator::I8x16LtS } + fn visit_i8x16_lt_u(&mut self, _offset: usize) -> Self::Output { Operator::I8x16LtU } + fn visit_i8x16_gt_s(&mut self, _offset: usize) -> Self::Output { Operator::I8x16GtS } + fn visit_i8x16_gt_u(&mut self, _offset: usize) -> Self::Output { Operator::I8x16GtU } + fn visit_i8x16_le_s(&mut self, _offset: usize) -> Self::Output { Operator::I8x16LeS } + fn visit_i8x16_le_u(&mut self, _offset: usize) -> Self::Output { Operator::I8x16LeU } + fn visit_i8x16_ge_s(&mut self, _offset: usize) -> Self::Output { Operator::I8x16GeS } + fn visit_i8x16_ge_u(&mut self, _offset: usize) -> Self::Output { Operator::I8x16GeU } + fn visit_i16x8_eq(&mut self, _offset: usize) -> Self::Output { Operator::I16x8Eq } + fn visit_i16x8_ne(&mut self, _offset: usize) -> Self::Output { Operator::I16x8Ne } + fn visit_i16x8_lt_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8LtS } + fn visit_i16x8_lt_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8LtU } + fn visit_i16x8_gt_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8GtS } + fn visit_i16x8_gt_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8GtU } + fn visit_i16x8_le_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8LeS } + fn visit_i16x8_le_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8LeU } + fn visit_i16x8_ge_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8GeS } + fn visit_i16x8_ge_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8GeU } + fn visit_i32x4_eq(&mut self, _offset: usize) -> Self::Output { Operator::I32x4Eq } + fn visit_i32x4_ne(&mut self, _offset: usize) -> Self::Output { Operator::I32x4Ne } + fn visit_i32x4_lt_s(&mut self, _offset: usize) -> Self::Output { Operator::I32x4LtS } + fn visit_i32x4_lt_u(&mut self, _offset: usize) -> Self::Output { Operator::I32x4LtU } + fn visit_i32x4_gt_s(&mut self, _offset: usize) -> Self::Output { Operator::I32x4GtS } + fn visit_i32x4_gt_u(&mut self, _offset: usize) -> Self::Output { Operator::I32x4GtU } + fn visit_i32x4_le_s(&mut self, _offset: usize) -> Self::Output { Operator::I32x4LeS } + fn visit_i32x4_le_u(&mut self, _offset: usize) -> Self::Output { Operator::I32x4LeU } + fn visit_i32x4_ge_s(&mut self, _offset: usize) -> Self::Output { Operator::I32x4GeS } + fn visit_i32x4_ge_u(&mut self, _offset: usize) -> Self::Output { Operator::I32x4GeU } + fn visit_i64x2_eq(&mut self, _offset: usize) -> Self::Output { Operator::I64x2Eq } + fn visit_i64x2_ne(&mut self, _offset: usize) -> Self::Output { Operator::I64x2Ne } + fn visit_i64x2_lt_s(&mut self, _offset: usize) -> Self::Output { Operator::I64x2LtS } + fn visit_i64x2_gt_s(&mut self, _offset: usize) -> Self::Output { Operator::I64x2GtS } + fn visit_i64x2_le_s(&mut self, _offset: usize) -> Self::Output { Operator::I64x2LeS } + fn visit_i64x2_ge_s(&mut self, _offset: usize) -> Self::Output { Operator::I64x2GeS } + fn visit_v128_and(&mut self, _offset: usize) -> Self::Output { Operator::V128And } + fn visit_v128_and_not(&mut self, _offset: usize) -> Self::Output { Operator::V128AndNot } + fn visit_v128_or(&mut self, _offset: usize) -> Self::Output { Operator::V128Or } + fn visit_v128_xor(&mut self, _offset: usize) -> Self::Output { Operator::V128Xor } + fn visit_i8x16_add(&mut self, _offset: usize) -> Self::Output { Operator::I8x16Add } + fn visit_i8x16_add_sat_s(&mut self, _offset: usize) -> Self::Output { Operator::I8x16AddSatS } + fn visit_i8x16_add_sat_u(&mut self, _offset: usize) -> Self::Output { Operator::I8x16AddSatU } + fn visit_i8x16_sub(&mut self, _offset: usize) -> Self::Output { Operator::I8x16Sub } + fn visit_i8x16_sub_sat_s(&mut self, _offset: usize) -> Self::Output { Operator::I8x16SubSatS } + fn visit_i8x16_sub_sat_u(&mut self, _offset: usize) -> Self::Output { Operator::I8x16SubSatU } + fn visit_i8x16_min_s(&mut self, _offset: usize) -> Self::Output { Operator::I8x16MinS } + fn visit_i8x16_min_u(&mut self, _offset: usize) -> Self::Output { Operator::I8x16MinU } + fn visit_i8x16_max_s(&mut self, _offset: usize) -> Self::Output { Operator::I8x16MaxS } + fn visit_i8x16_max_u(&mut self, _offset: usize) -> Self::Output { Operator::I8x16MaxU } + fn visit_i16x8_add(&mut self, _offset: usize) -> Self::Output { Operator::I16x8Add } + fn visit_i16x8_add_sat_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8AddSatS } + fn visit_i16x8_add_sat_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8AddSatU } + fn visit_i16x8_sub(&mut self, _offset: usize) -> Self::Output { Operator::I16x8Sub } + fn visit_i16x8_sub_sat_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8SubSatS } + fn visit_i16x8_sub_sat_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8SubSatU } + fn visit_i16x8_mul(&mut self, _offset: usize) -> Self::Output { Operator::I16x8Mul } + fn visit_i16x8_min_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8MinS } + fn visit_i16x8_min_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8MinU } + fn visit_i16x8_max_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8MaxS } + fn visit_i16x8_max_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8MaxU } + fn visit_i32x4_add(&mut self, _offset: usize) -> Self::Output { Operator::I32x4Add } + fn visit_i32x4_sub(&mut self, _offset: usize) -> Self::Output { Operator::I32x4Sub } + fn visit_i32x4_mul(&mut self, _offset: usize) -> Self::Output { Operator::I32x4Mul } + fn visit_i32x4_min_s(&mut self, _offset: usize) -> Self::Output { Operator::I32x4MinS } + fn visit_i32x4_min_u(&mut self, _offset: usize) -> Self::Output { Operator::I32x4MinU } + fn visit_i32x4_max_s(&mut self, _offset: usize) -> Self::Output { Operator::I32x4MaxS } + fn visit_i32x4_max_u(&mut self, _offset: usize) -> Self::Output { Operator::I32x4MaxU } + fn visit_i32x4_dot_i16x8_s(&mut self, _offset: usize) -> Self::Output { Operator::I32x4DotI16x8S } + fn visit_i64x2_add(&mut self, _offset: usize) -> Self::Output { Operator::I64x2Add } + fn visit_i64x2_sub(&mut self, _offset: usize) -> Self::Output { Operator::I64x2Sub } + fn visit_i64x2_mul(&mut self, _offset: usize) -> Self::Output { Operator::I64x2Mul } + fn visit_i8x16_rounding_average_u(&mut self, _offset: usize) -> Self::Output { Operator::I8x16RoundingAverageU } + fn visit_i16x8_rounding_average_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8RoundingAverageU } + fn visit_i8x16_narrow_i16x8_s(&mut self, _offset: usize) -> Self::Output { Operator::I8x16NarrowI16x8S } + fn visit_i8x16_narrow_i16x8_u(&mut self, _offset: usize) -> Self::Output { Operator::I8x16NarrowI16x8U } + fn visit_i16x8_narrow_i32x4_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8NarrowI32x4S } + fn visit_i16x8_narrow_i32x4_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8NarrowI32x4U } + fn visit_i16x8_ext_mul_low_i8x16_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8ExtMulLowI8x16S } + fn visit_i16x8_ext_mul_high_i8x16_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8ExtMulHighI8x16S } + fn visit_i16x8_ext_mul_low_i8x16_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8ExtMulLowI8x16U } + fn visit_i16x8_ext_mul_high_i8x16_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8ExtMulHighI8x16U } + fn visit_i32x4_ext_mul_low_i16x8_s(&mut self, _offset: usize) -> Self::Output { Operator::I32x4ExtMulLowI16x8S } + fn visit_i32x4_ext_mul_high_i16x8_s(&mut self, _offset: usize) -> Self::Output { Operator::I32x4ExtMulHighI16x8S } + fn visit_i32x4_ext_mul_low_i16x8_u(&mut self, _offset: usize) -> Self::Output { Operator::I32x4ExtMulLowI16x8U } + fn visit_i32x4_ext_mul_high_i16x8_u(&mut self, _offset: usize) -> Self::Output { Operator::I32x4ExtMulHighI16x8U } + fn visit_i64x2_ext_mul_low_i32x4_s(&mut self, _offset: usize) -> Self::Output { Operator::I64x2ExtMulLowI32x4S } + fn visit_i64x2_ext_mul_high_i32x4_s(&mut self, _offset: usize) -> Self::Output { Operator::I64x2ExtMulHighI32x4S } + fn visit_i64x2_ext_mul_low_i32x4_u(&mut self, _offset: usize) -> Self::Output { Operator::I64x2ExtMulLowI32x4U } + fn visit_i64x2_ext_mul_high_i32x4_u(&mut self, _offset: usize) -> Self::Output { Operator::I64x2ExtMulHighI32x4U } + fn visit_i16x8_q15_mulr_sat_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8Q15MulrSatS } + fn visit_f32x4_ceil(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Ceil } + fn visit_f32x4_floor(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Floor } + fn visit_f32x4_trunc(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Trunc } + fn visit_f32x4_nearest(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Nearest } + fn visit_f64x2_ceil(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Ceil } + fn visit_f64x2_floor(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Floor } + fn visit_f64x2_trunc(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Trunc } + fn visit_f64x2_nearest(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Nearest } + fn visit_f32x4_abs(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Abs } + fn visit_f32x4_neg(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Neg } + fn visit_f32x4_sqrt(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Sqrt } + fn visit_f64x2_abs(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Abs } + fn visit_f64x2_neg(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Neg } + fn visit_f64x2_sqrt(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Sqrt } + fn visit_f32x4_demote_f64x2_zero(&mut self, _offset: usize) -> Self::Output { Operator::F32x4DemoteF64x2Zero } + fn visit_f64x2_promote_low_f32x4(&mut self, _offset: usize) -> Self::Output { Operator::F64x2PromoteLowF32x4 } + fn visit_f64x2_convert_low_i32x4_s(&mut self, _offset: usize) -> Self::Output { Operator::F64x2ConvertLowI32x4S } + fn visit_f64x2_convert_low_i32x4_u(&mut self, _offset: usize) -> Self::Output { Operator::F64x2ConvertLowI32x4U } + fn visit_i32x4_trunc_sat_f32x4_s(&mut self, _offset: usize) -> Self::Output { Operator::I32x4TruncSatF32x4S } + fn visit_i32x4_trunc_sat_f32x4_u(&mut self, _offset: usize) -> Self::Output { Operator::I32x4TruncSatF32x4U } + fn visit_i32x4_trunc_sat_f64x2_s_zero(&mut self, _offset: usize) -> Self::Output { Operator::I32x4TruncSatF64x2SZero } + fn visit_i32x4_trunc_sat_f64x2_u_zero(&mut self, _offset: usize) -> Self::Output { Operator::I32x4TruncSatF64x2UZero } + fn visit_f32x4_convert_i32x4_s(&mut self, _offset: usize) -> Self::Output { Operator::F32x4ConvertI32x4S } + fn visit_f32x4_convert_i32x4_u(&mut self, _offset: usize) -> Self::Output { Operator::F32x4ConvertI32x4U } + fn visit_v128_not(&mut self, _offset: usize) -> Self::Output { Operator::V128Not } + fn visit_i8x16_abs(&mut self, _offset: usize) -> Self::Output { Operator::I8x16Abs } + fn visit_i8x16_neg(&mut self, _offset: usize) -> Self::Output { Operator::I8x16Neg } + fn visit_i8x16_popcnt(&mut self, _offset: usize) -> Self::Output { Operator::I8x16Popcnt } + fn visit_i16x8_abs(&mut self, _offset: usize) -> Self::Output { Operator::I16x8Abs } + fn visit_i16x8_neg(&mut self, _offset: usize) -> Self::Output { Operator::I16x8Neg } + fn visit_i32x4_abs(&mut self, _offset: usize) -> Self::Output { Operator::I32x4Abs } + fn visit_i32x4_neg(&mut self, _offset: usize) -> Self::Output { Operator::I32x4Neg } + fn visit_i64x2_abs(&mut self, _offset: usize) -> Self::Output { Operator::I64x2Abs } + fn visit_i64x2_neg(&mut self, _offset: usize) -> Self::Output { Operator::I64x2Neg } + fn visit_i16x8_extend_low_i8x16_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8ExtendLowI8x16S } + fn visit_i16x8_extend_high_i8x16_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8ExtendHighI8x16S } + fn visit_i16x8_extend_low_i8x16_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8ExtendLowI8x16U } + fn visit_i16x8_extend_high_i8x16_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8ExtendHighI8x16U } + fn visit_i32x4_extend_low_i16x8_s(&mut self, _offset: usize) -> Self::Output { Operator::I32x4ExtendLowI16x8S } + fn visit_i32x4_extend_high_i16x8_s(&mut self, _offset: usize) -> Self::Output { Operator::I32x4ExtendHighI16x8S } + fn visit_i32x4_extend_low_i16x8_u(&mut self, _offset: usize) -> Self::Output { Operator::I32x4ExtendLowI16x8U } + fn visit_i32x4_extend_high_i16x8_u(&mut self, _offset: usize) -> Self::Output { Operator::I32x4ExtendHighI16x8U } + fn visit_i64x2_extend_low_i32x4_s(&mut self, _offset: usize) -> Self::Output { Operator::I64x2ExtendLowI32x4S } + fn visit_i64x2_extend_high_i32x4_s(&mut self, _offset: usize) -> Self::Output { Operator::I64x2ExtendHighI32x4S } + fn visit_i64x2_extend_low_i32x4_u(&mut self, _offset: usize) -> Self::Output { Operator::I64x2ExtendLowI32x4U } + fn visit_i64x2_extend_high_i32x4_u(&mut self, _offset: usize) -> Self::Output { Operator::I64x2ExtendHighI32x4U } + fn visit_i16x8_ext_add_pairwise_i8x16_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8ExtAddPairwiseI8x16S } + fn visit_i16x8_ext_add_pairwise_i8x16_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8ExtAddPairwiseI8x16U } + fn visit_i32x4_ext_add_pairwise_i16x8_s(&mut self, _offset: usize) -> Self::Output { Operator::I32x4ExtAddPairwiseI16x8S } + fn visit_i32x4_ext_add_pairwise_i16x8_u(&mut self, _offset: usize) -> Self::Output { Operator::I32x4ExtAddPairwiseI16x8U } + fn visit_i32x4_relaxed_trunc_sat_f32x4_s(&mut self, _offset: usize) -> Self::Output { Operator::I32x4RelaxedTruncSatF32x4S } + fn visit_i32x4_relaxed_trunc_sat_f32x4_u(&mut self, _offset: usize) -> Self::Output { Operator::I32x4RelaxedTruncSatF32x4U } + fn visit_i32x4_relaxed_trunc_sat_f64x2_s_zero(&mut self, _offset: usize) -> Self::Output { Operator::I32x4RelaxedTruncSatF64x2SZero } + fn visit_i32x4_relaxed_trunc_sat_f64x2_u_zero(&mut self, _offset: usize) -> Self::Output { Operator::I32x4RelaxedTruncSatF64x2UZero } + fn visit_v128_bitselect(&mut self, _offset: usize) -> Self::Output { Operator::V128Bitselect } + fn visit_f32x4_fma(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Fma } + fn visit_f32x4_fms(&mut self, _offset: usize) -> Self::Output { Operator::F32x4Fms } + fn visit_f64x2_fma(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Fma } + fn visit_f64x2_fms(&mut self, _offset: usize) -> Self::Output { Operator::F64x2Fms } + fn visit_i8x16_lane_select(&mut self, _offset: usize) -> Self::Output { Operator::I8x16LaneSelect } + fn visit_i16x8_lane_select(&mut self, _offset: usize) -> Self::Output { Operator::I16x8LaneSelect } + fn visit_i32x4_lane_select(&mut self, _offset: usize) -> Self::Output { Operator::I32x4LaneSelect } + fn visit_i64x2_lane_select(&mut self, _offset: usize) -> Self::Output { Operator::I64x2LaneSelect } + fn visit_v128_any_true(&mut self, _offset: usize) -> Self::Output { Operator::V128AnyTrue } + fn visit_i8x16_all_true(&mut self, _offset: usize) -> Self::Output { Operator::I8x16AllTrue } + fn visit_i8x16_bitmask(&mut self, _offset: usize) -> Self::Output { Operator::I8x16Bitmask } + fn visit_i16x8_all_true(&mut self, _offset: usize) -> Self::Output { Operator::I16x8AllTrue } + fn visit_i16x8_bitmask(&mut self, _offset: usize) -> Self::Output { Operator::I16x8Bitmask } + fn visit_i32x4_all_true(&mut self, _offset: usize) -> Self::Output { Operator::I32x4AllTrue } + fn visit_i32x4_bitmask(&mut self, _offset: usize) -> Self::Output { Operator::I32x4Bitmask } + fn visit_i64x2_all_true(&mut self, _offset: usize) -> Self::Output { Operator::I64x2AllTrue } + fn visit_i64x2_bitmask(&mut self, _offset: usize) -> Self::Output { Operator::I64x2Bitmask } + fn visit_i8x16_shl(&mut self, _offset: usize) -> Self::Output { Operator::I8x16Shl } + fn visit_i8x16_shr_s(&mut self, _offset: usize) -> Self::Output { Operator::I8x16ShrS } + fn visit_i8x16_shr_u(&mut self, _offset: usize) -> Self::Output { Operator::I8x16ShrU } + fn visit_i16x8_shl(&mut self, _offset: usize) -> Self::Output { Operator::I16x8Shl } + fn visit_i16x8_shr_s(&mut self, _offset: usize) -> Self::Output { Operator::I16x8ShrS } + fn visit_i16x8_shr_u(&mut self, _offset: usize) -> Self::Output { Operator::I16x8ShrU } + fn visit_i32x4_shl(&mut self, _offset: usize) -> Self::Output { Operator::I32x4Shl } + fn visit_i32x4_shr_s(&mut self, _offset: usize) -> Self::Output { Operator::I32x4ShrS } + fn visit_i32x4_shr_u(&mut self, _offset: usize) -> Self::Output { Operator::I32x4ShrU } + fn visit_i64x2_shl(&mut self, _offset: usize) -> Self::Output { Operator::I64x2Shl } + fn visit_i64x2_shr_s(&mut self, _offset: usize) -> Self::Output { Operator::I64x2ShrS } + fn visit_i64x2_shr_u(&mut self, _offset: usize) -> Self::Output { Operator::I64x2ShrU } + fn visit_i8x16_swizzle(&mut self, _offset: usize) -> Self::Output { Operator::I8x16Swizzle } + fn visit_i8x16_relaxed_swizzle(&mut self, _offset: usize) -> Self::Output { Operator::I8x16RelaxedSwizzle } + fn visit_i8x16_shuffle(&mut self, _offset: usize, lanes: [SIMDLaneIndex; 16]) -> Self::Output { Operator::I8x16Shuffle { lanes } } + fn visit_v128_load8_splat(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::V128Load8Splat { memarg } } + fn visit_v128_load16_splat(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::V128Load16Splat { memarg } } + fn visit_v128_load32_splat(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::V128Load32Splat { memarg } } + fn visit_v128_load32_zero(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::V128Load32Zero { memarg } } + fn visit_v128_load64_splat(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::V128Load64Splat { memarg } } + fn visit_v128_load64_zero(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::V128Load64Zero { memarg } } + fn visit_v128_load8x8_s(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::V128Load8x8S { memarg } } + fn visit_v128_load8x8_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::V128Load8x8U { memarg } } + fn visit_v128_load16x4_s(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::V128Load16x4S { memarg } } + fn visit_v128_load16x4_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::V128Load16x4U { memarg } } + fn visit_v128_load32x2_s(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::V128Load32x2S { memarg } } + fn visit_v128_load32x2_u(&mut self, _offset: usize, memarg: MemoryImmediate) -> Self::Output { Operator::V128Load32x2U { memarg } } + fn visit_v128_load8_lane(&mut self, _offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { Operator::V128Load8Lane { memarg, lane } } + fn visit_v128_load16_lane(&mut self, _offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { Operator::V128Load16Lane { memarg, lane } } + fn visit_v128_load32_lane(&mut self, _offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { Operator::V128Load32Lane { memarg, lane } } + fn visit_v128_load64_lane(&mut self, _offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { Operator::V128Load64Lane { memarg, lane } } + fn visit_v128_store8_lane(&mut self, _offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { Operator::V128Store8Lane { memarg, lane } } + fn visit_v128_store16_lane(&mut self, _offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { Operator::V128Store16Lane { memarg, lane } } + fn visit_v128_store32_lane(&mut self, _offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { Operator::V128Store32Lane { memarg, lane } } + fn visit_v128_store64_lane(&mut self, _offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { Operator::V128Store64Lane { memarg, lane } } + fn visit_memory_init(&mut self, _offset: usize, segment: u32, mem: u32) -> Self::Output { Operator::MemoryInit { mem, segment } } + fn visit_data_drop(&mut self, _offset: usize, segment: u32) -> Self::Output { Operator::DataDrop { segment } } + fn visit_memory_copy(&mut self, _offset: usize, dst: u32, src: u32) -> Self::Output { Operator::MemoryCopy { src, dst } } + fn visit_memory_fill(&mut self, _offset: usize, mem: u32) -> Self::Output { Operator::MemoryFill { mem } } + fn visit_table_init(&mut self, _offset: usize, segment: u32, table: u32) -> Self::Output { Operator::TableInit { segment, table } } + fn visit_elem_drop(&mut self, _offset: usize, segment: u32) -> Self::Output { Operator::ElemDrop { segment } } + fn visit_table_copy(&mut self, _offset: usize, dst_table: u32, src_table: u32) -> Self::Output { Operator::TableCopy { dst_table, src_table } } + fn visit_table_get(&mut self, _offset: usize, table: u32) -> Self::Output { Operator::TableGet { table } } + fn visit_table_set(&mut self, _offset: usize, table: u32) -> Self::Output { Operator::TableSet { table } } + fn visit_table_grow(&mut self, _offset: usize, table: u32) -> Self::Output { Operator::TableGrow { table } } + fn visit_table_size(&mut self, _offset: usize, table: u32) -> Self::Output { Operator::TableSize { table } } + fn visit_table_fill(&mut self, _offset: usize, table: u32) -> Self::Output { Operator::TableFill { table } } + + fn visit_memory_read_pkru(&mut self, _offset: usize) -> Self::Output { Operator::Rdpkru } + fn visit_memory_write_pkru(&mut self, _offset: usize) -> Self::Output { Operator::Wrpkru } +} diff --git a/crates/wasmparser/src/lib.rs b/crates/wasmparser/src/lib.rs new file mode 100644 index 000000000..6c8e14186 --- /dev/null +++ b/crates/wasmparser/src/lib.rs @@ -0,0 +1,39 @@ +/* Copyright 2017 Mozilla Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//! A simple event-driven library for parsing WebAssembly binary files +//! (or streams). +//! +//! The parser library reports events as they happen and only stores +//! parsing information for a brief period of time, making it very fast +//! and memory-efficient. The event-driven model, however, has some drawbacks. +//! If you need random access to the entire WebAssembly data-structure, +//! this is not the right library for you. You could however, build such +//! a data-structure using this library. + +#![deny(missing_docs)] + +pub use crate::binary_reader::{BinaryReader, BinaryReaderError, Result}; +pub use crate::parser::*; +pub use crate::readers::*; +pub use crate::resources::*; +pub use crate::validator::*; + +mod binary_reader; +mod limits; +mod parser; +mod readers; +mod resources; +mod validator; \ No newline at end of file diff --git a/crates/wasmparser/src/limits.rs b/crates/wasmparser/src/limits.rs new file mode 100644 index 000000000..a8a3011c0 --- /dev/null +++ b/crates/wasmparser/src/limits.rs @@ -0,0 +1,57 @@ +/* Copyright 2017 Mozilla Foundation + * + * 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 following limits are imposed by wasmparser on WebAssembly modules. +// The limits are agreed upon with other engines for consistency. +pub const MAX_WASM_TYPES: usize = 1_000_000; +pub const MAX_WASM_FUNCTIONS: usize = 1_000_000; +pub const MAX_WASM_EXPORTS: usize = 100_000; +pub const MAX_WASM_GLOBALS: usize = 1_000_000; +pub const MAX_WASM_ELEMENT_SEGMENTS: usize = 100_000; +pub const MAX_WASM_DATA_SEGMENTS: usize = 100_000; +pub const MAX_WASM_MEMORY32_PAGES: u64 = 65536; +pub const MAX_WASM_MEMORY64_PAGES: u64 = 1 << 48; +pub const MAX_WASM_STRING_SIZE: usize = 100_000; +pub const MAX_WASM_FUNCTION_SIZE: usize = 128 * 1024; +pub const MAX_WASM_FUNCTION_LOCALS: usize = 50000; +pub const MAX_WASM_FUNCTION_PARAMS: usize = 1000; +pub const MAX_WASM_FUNCTION_RETURNS: usize = 1000; +pub const _MAX_WASM_TABLE_SIZE: usize = 10_000_000; +pub const MAX_WASM_TABLE_ENTRIES: usize = 10_000_000; +pub const MAX_WASM_TABLES: usize = 100; +pub const MAX_WASM_MEMORIES: usize = 100; +pub const MAX_WASM_TAGS: usize = 1_000_000; +pub const MAX_WASM_BR_TABLE_SIZE: usize = MAX_WASM_FUNCTION_SIZE; + +// Component-related limits +pub const MAX_WASM_MODULE_SIZE: usize = 1024 * 1024 * 1024; //= 1 GiB +pub const MAX_WASM_MODULE_TYPE_DECLS: usize = 1000; +pub const MAX_WASM_COMPONENT_TYPE_DECLS: usize = 1000; +pub const MAX_WASM_INSTANCE_TYPE_DECLS: usize = 1000; +pub const MAX_WASM_RECORD_FIELDS: usize = 1000; +pub const MAX_WASM_VARIANT_CASES: usize = 1000; +pub const MAX_WASM_TUPLE_TYPES: usize = 1000; +pub const MAX_WASM_FLAG_NAMES: usize = 1000; +pub const MAX_WASM_ENUM_CASES: usize = 1000; +pub const MAX_WASM_UNION_TYPES: usize = 1000; +pub const MAX_WASM_INSTANTIATION_EXPORTS: usize = 1000; +pub const MAX_WASM_CANONICAL_OPTIONS: usize = 10; +pub const MAX_WASM_INSTANTIATION_ARGS: usize = 1000; +pub const MAX_WASM_START_ARGS: usize = 1000; +pub const MAX_WASM_TYPE_SIZE: usize = 100_000; +pub const MAX_WASM_MODULES: usize = 1_000; +pub const MAX_WASM_COMPONENTS: usize = 1_000; +pub const MAX_WASM_INSTANCES: usize = 1_000; +pub const MAX_WASM_VALUES: usize = 1_000; diff --git a/crates/wasmparser/src/parser.rs b/crates/wasmparser/src/parser.rs new file mode 100644 index 000000000..bd49aecf8 --- /dev/null +++ b/crates/wasmparser/src/parser.rs @@ -0,0 +1,1434 @@ +use crate::CoreTypeSectionReader; +use crate::{ + limits::MAX_WASM_MODULE_SIZE, AliasSectionReader, BinaryReader, BinaryReaderError, + ComponentAliasSectionReader, ComponentCanonicalSectionReader, ComponentExportSectionReader, + ComponentImportSectionReader, ComponentInstanceSectionReader, ComponentStartSectionReader, + ComponentTypeSectionReader, CustomSectionReader, DataSectionReader, ElementSectionReader, + ExportSectionReader, FunctionBody, FunctionSectionReader, GlobalSectionReader, + ImportSectionReader, InstanceSectionReader, MemorySectionReader, Result, TableSectionReader, + TagSectionReader, TypeSectionReader, +}; +use std::convert::TryInto; +use std::fmt; +use std::iter; +use std::ops::Range; + +pub(crate) const WASM_EXPERIMENTAL_VERSION: u32 = 0xd; +pub(crate) const WASM_MODULE_VERSION: u32 = 0x1; +pub(crate) const WASM_COMPONENT_VERSION: u32 = 0x0001000a; + +/// The supported encoding formats for the parser. +#[derive(Debug, Clone, Copy, Eq, PartialEq)] +pub enum Encoding { + /// The encoding format is a WebAssembly module. + Module, + /// The encoding format is a WebAssembly component. + Component, +} + +/// An incremental parser of a binary WebAssembly module or component. +/// +/// This type is intended to be used to incrementally parse a WebAssembly module +/// or component as bytes become available for the module. This can also be used +/// to parse modules or components that are already entirely resident within memory. +/// +/// This primary function for a parser is the [`Parser::parse`] function which +/// will incrementally consume input. You can also use the [`Parser::parse_all`] +/// function to parse a module or component that is entirely resident in memory. +#[derive(Debug, Clone)] +pub struct Parser { + state: State, + offset: u64, + max_size: u64, + encoding: Encoding, +} + +#[derive(Debug, Clone)] +enum State { + Header, + SectionStart, + FunctionBody { remaining: u32, len: u32 }, +} + +/// A successful return payload from [`Parser::parse`]. +/// +/// On success one of two possible values can be returned, either that more data +/// is needed to continue parsing or a chunk of the input was parsed, indicating +/// how much of it was parsed. +#[derive(Debug)] +pub enum Chunk<'a> { + /// This can be returned at any time and indicates that more data is needed + /// to proceed with parsing. Zero bytes were consumed from the input to + /// [`Parser::parse`]. The `usize` value here is a hint as to how many more + /// bytes are needed to continue parsing. + NeedMoreData(u64), + + /// A chunk was successfully parsed. + Parsed { + /// This many bytes of the `data` input to [`Parser::parse`] were + /// consumed to produce `payload`. + consumed: usize, + /// The value that we actually parsed. + payload: Payload<'a>, + }, +} + +/// Values that can be parsed from a WebAssembly module or component. +/// +/// This enumeration is all possible chunks of pieces that can be parsed by a +/// [`Parser`] from a binary WebAssembly module or component. Note that for many +/// sections the entire section is parsed all at once, whereas other functions, +/// like the code section, are parsed incrementally. This is a distinction where some +/// sections, like the type section, are required to be fully resident in memory +/// (fully downloaded) before proceeding. Other sections, like the code section, +/// can be processed in a streaming fashion where each function is extracted +/// individually so it can possibly be shipped to another thread while you wait +/// for more functions to get downloaded. +/// +/// Note that payloads, when returned, do not indicate that the module or component +/// is valid. For example when you receive a `Payload::TypeSection` the type +/// section itself has not yet actually been parsed. The reader returned will be +/// able to parse it, but you'll have to actually iterate the reader to do the +/// full parse. Each payload returned is intended to be a *window* into the +/// original `data` passed to [`Parser::parse`] which can be further processed +/// if necessary. +pub enum Payload<'a> { + /// Indicates the header of a WebAssembly module or component. + Version { + /// The version number found in the header. + num: u32, + /// The encoding format being parsed. + encoding: Encoding, + /// The range of bytes that were parsed to consume the header of the + /// module or component. Note that this range is relative to the start + /// of the byte stream. + range: Range, + }, + + /// A module type section was received and the provided reader can be + /// used to parse the contents of the type section. + TypeSection(TypeSectionReader<'a>), + /// A module import section was received and the provided reader can be + /// used to parse the contents of the import section. + ImportSection(ImportSectionReader<'a>), + /// A module function section was received and the provided reader can be + /// used to parse the contents of the function section. + FunctionSection(FunctionSectionReader<'a>), + /// A module table section was received and the provided reader can be + /// used to parse the contents of the table section. + TableSection(TableSectionReader<'a>), + /// A module memory section was received and the provided reader can be + /// used to parse the contents of the memory section. + MemorySection(MemorySectionReader<'a>), + /// A module tag section was received, and the provided reader can be + /// used to parse the contents of the tag section. + TagSection(TagSectionReader<'a>), + /// A module global section was received and the provided reader can be + /// used to parse the contents of the global section. + GlobalSection(GlobalSectionReader<'a>), + /// A module export section was received, and the provided reader can be + /// used to parse the contents of the export section. + ExportSection(ExportSectionReader<'a>), + /// A module start section was received. + StartSection { + /// The start function index + func: u32, + /// The range of bytes that specify the `func` field, specified in + /// offsets relative to the start of the byte stream. + range: Range, + }, + /// A module element section was received and the provided reader can be + /// used to parse the contents of the element section. + ElementSection(ElementSectionReader<'a>), + /// A module data count section was received. + DataCountSection { + /// The number of data segments. + count: u32, + /// The range of bytes that specify the `count` field, specified in + /// offsets relative to the start of the byte stream. + range: Range, + }, + /// A module data section was received and the provided reader can be + /// used to parse the contents of the data section. + DataSection(DataSectionReader<'a>), + /// Indicator of the start of the code section of a WebAssembly module. + /// + /// This entry is returned whenever the code section starts. The `count` + /// field indicates how many entries are in this code section. After + /// receiving this start marker you're guaranteed that the next `count` + /// items will be either `CodeSectionEntry` or an error will be returned. + /// + /// This, unlike other sections, is intended to be used for streaming the + /// contents of the code section. The code section is not required to be + /// fully resident in memory when we parse it. Instead a [`Parser`] is + /// capable of parsing piece-by-piece of a code section. + CodeSectionStart { + /// The number of functions in this section. + count: u32, + /// The range of bytes that represent this section, specified in + /// offsets relative to the start of the byte stream. + range: Range, + /// The size, in bytes, of the remaining contents of this section. + /// + /// This can be used in combination with [`Parser::skip_section`] + /// where the caller will know how many bytes to skip before feeding + /// bytes into `Parser` again. + size: u32, + }, + /// An entry of the code section, a function, was parsed from a WebAssembly + /// module. + /// + /// This entry indicates that a function was successfully received from the + /// code section, and the payload here is the window into the original input + /// where the function resides. Note that the function itself has not been + /// parsed, it's only been outlined. You'll need to process the + /// `FunctionBody` provided to test whether it parses and/or is valid. + CodeSectionEntry(FunctionBody<'a>), + + /// A core module section was received and the provided parser can be + /// used to parse the nested module. + /// + /// This variant is special in that it returns a sub-`Parser`. Upon + /// receiving a `ModuleSection` it is expected that the returned + /// `Parser` will be used instead of the parent `Parser` until the parse has + /// finished. You'll need to feed data into the `Parser` returned until it + /// returns `Payload::End`. After that you'll switch back to the parent + /// parser to resume parsing the rest of the current component. + /// + /// Note that binaries will not be parsed correctly if you feed the data for + /// a nested module into the parent [`Parser`]. + ModuleSection { + /// The parser for the nested module. + parser: Parser, + /// The range of bytes that represent the nested module in the + /// original byte stream. + range: Range, + }, + /// A core instance section was received and the provided parser can be + /// used to parse the contents of the core instance section. + /// + /// Currently this section is only parsed in a component. + InstanceSection(InstanceSectionReader<'a>), + /// A core alias section was received and the provided parser can be + /// used to parse the contents of the core alias section. + /// + /// Currently this section is only parsed in a component. + AliasSection(AliasSectionReader<'a>), + /// A core type section was received and the provided parser can be + /// used to parse the contents of the core type section. + /// + /// Currently this section is only parsed in a component. + CoreTypeSection(CoreTypeSectionReader<'a>), + /// A component section from a WebAssembly component was received and the + /// provided parser can be used to parse the nested component. + /// + /// This variant is special in that it returns a sub-`Parser`. Upon + /// receiving a `ComponentSection` it is expected that the returned + /// `Parser` will be used instead of the parent `Parser` until the parse has + /// finished. You'll need to feed data into the `Parser` returned until it + /// returns `Payload::End`. After that you'll switch back to the parent + /// parser to resume parsing the rest of the current component. + /// + /// Note that binaries will not be parsed correctly if you feed the data for + /// a nested component into the parent [`Parser`]. + ComponentSection { + /// The parser for the nested component. + parser: Parser, + /// The range of bytes that represent the nested component in the + /// original byte stream. + range: Range, + }, + /// A component instance section was received and the provided reader can be + /// used to parse the contents of the component instance section. + ComponentInstanceSection(ComponentInstanceSectionReader<'a>), + /// A component alias section was received and the provided reader can be + /// used to parse the contents of the component alias section. + ComponentAliasSection(ComponentAliasSectionReader<'a>), + /// A component type section was received and the provided reader can be + /// used to parse the contents of the component type section. + ComponentTypeSection(ComponentTypeSectionReader<'a>), + /// A component canonical section was received and the provided reader can be + /// used to parse the contents of the component canonical section. + ComponentCanonicalSection(ComponentCanonicalSectionReader<'a>), + /// A component start section was received, and the provided reader can be + /// used to parse the contents of the component start section. + ComponentStartSection(ComponentStartSectionReader<'a>), + /// A component import section was received and the provided reader can be + /// used to parse the contents of the component import section. + ComponentImportSection(ComponentImportSectionReader<'a>), + /// A component export section was received, and the provided reader can be + /// used to parse the contents of the component export section. + ComponentExportSection(ComponentExportSectionReader<'a>), + + /// A module or component custom section was received. + CustomSection(CustomSectionReader<'a>), + + /// An unknown section was found. + /// + /// This variant is returned for all unknown sections encountered. This + /// likely wants to be interpreted as an error by consumers of the parser, + /// but this can also be used to parse sections currently unsupported by + /// the parser. + UnknownSection { + /// The 8-bit identifier for this section. + id: u8, + /// The contents of this section. + contents: &'a [u8], + /// The range of bytes, relative to the start of the original data + /// stream, that the contents of this section reside in. + range: Range, + }, + + /// The end of the WebAssembly module or component was reached. + /// + /// The value is the offset in the input byte stream where the end + /// was reached. + End(usize), +} + +impl Parser { + /// Creates a new parser. + /// + /// Reports errors and ranges relative to `offset` provided, where `offset` + /// is some logical offset within the input stream that we're parsing. + pub fn new(offset: u64) -> Parser { + Parser { + state: State::Header, + offset, + max_size: u64::MAX, + // Assume the encoding is a module until we know otherwise + encoding: Encoding::Module, + } + } + + /// Attempts to parse a chunk of data. + /// + /// This method will attempt to parse the next incremental portion of a + /// WebAssembly binary. Data available for the module or component is + /// provided as `data`, and the data can be incomplete if more data has yet + /// to arrive. The `eof` flag indicates whether more data will ever be received. + /// + /// There are two ways parsing can succeed with this method: + /// + /// * `Chunk::NeedMoreData` - this indicates that there is not enough bytes + /// in `data` to parse a payload. The caller needs to wait for more data to + /// be available in this situation before calling this method again. It is + /// guaranteed that this is only returned if `eof` is `false`. + /// + /// * `Chunk::Parsed` - this indicates that a chunk of the input was + /// successfully parsed. The payload is available in this variant of what + /// was parsed, and this also indicates how many bytes of `data` was + /// consumed. It's expected that the caller will not provide these bytes + /// back to the [`Parser`] again. + /// + /// Note that all `Chunk` return values are connected, with a lifetime, to + /// the input buffer. Each parsed chunk borrows the input buffer and is a + /// view into it for successfully parsed chunks. + /// + /// It is expected that you'll call this method until `Payload::End` is + /// reached, at which point you're guaranteed that the parse has completed. + /// Note that complete parsing, for the top-level module or component, + /// implies that `data` is empty and `eof` is `true`. + /// + /// # Errors + /// + /// Parse errors are returned as an `Err`. Errors can happen when the + /// structure of the data is unexpected or if sections are too large for + /// example. Note that errors are not returned for malformed *contents* of + /// sections here. Sections are generally not individually parsed and each + /// returned [`Payload`] needs to be iterated over further to detect all + /// errors. + /// + /// # Examples + /// + /// An example of reading a wasm file from a stream (`std::io::Read`) and + /// incrementally parsing it. + /// + /// ``` + /// use std::io::Read; + /// use anyhow::Result; + /// use wasmparser::{Parser, Chunk, Payload::*}; + /// + /// fn parse(mut reader: impl Read) -> Result<()> { + /// let mut buf = Vec::new(); + /// let mut parser = Parser::new(0); + /// let mut eof = false; + /// let mut stack = Vec::new(); + /// + /// loop { + /// let (payload, consumed) = match parser.parse(&buf, eof)? { + /// Chunk::NeedMoreData(hint) => { + /// assert!(!eof); // otherwise an error would be returned + /// + /// // Use the hint to preallocate more space, then read + /// // some more data into our buffer. + /// // + /// // Note that the buffer management here is not ideal, + /// // but it's compact enough to fit in an example! + /// let len = buf.len(); + /// buf.extend((0..hint).map(|_| 0u8)); + /// let n = reader.read(&mut buf[len..])?; + /// buf.truncate(len + n); + /// eof = n == 0; + /// continue; + /// } + /// + /// Chunk::Parsed { consumed, payload } => (payload, consumed), + /// }; + /// + /// match payload { + /// // Sections for WebAssembly modules + /// Version { .. } => { /* ... */ } + /// TypeSection(_) => { /* ... */ } + /// ImportSection(_) => { /* ... */ } + /// FunctionSection(_) => { /* ... */ } + /// TableSection(_) => { /* ... */ } + /// MemorySection(_) => { /* ... */ } + /// TagSection(_) => { /* ... */ } + /// GlobalSection(_) => { /* ... */ } + /// ExportSection(_) => { /* ... */ } + /// StartSection { .. } => { /* ... */ } + /// ElementSection(_) => { /* ... */ } + /// DataCountSection { .. } => { /* ... */ } + /// DataSection(_) => { /* ... */ } + /// + /// // Here we know how many functions we'll be receiving as + /// // `CodeSectionEntry`, so we can prepare for that, and + /// // afterwards we can parse and handle each function + /// // individually. + /// CodeSectionStart { .. } => { /* ... */ } + /// CodeSectionEntry(body) => { + /// // here we can iterate over `body` to parse the function + /// // and its locals + /// } + /// + /// // Sections for WebAssembly components + /// ModuleSection { .. } => { /* ... */ } + /// InstanceSection(_) => { /* ... */ } + /// AliasSection(_) => { /* ... */ } + /// CoreTypeSection(_) => { /* ... */ } + /// ComponentSection { .. } => { /* ... */ } + /// ComponentInstanceSection(_) => { /* ... */ } + /// ComponentAliasSection(_) => { /* ... */ } + /// ComponentTypeSection(_) => { /* ... */ } + /// ComponentCanonicalSection(_) => { /* ... */ } + /// ComponentStartSection { .. } => { /* ... */ } + /// ComponentImportSection(_) => { /* ... */ } + /// ComponentExportSection(_) => { /* ... */ } + /// + /// CustomSection(_) => { /* ... */ } + /// + /// // most likely you'd return an error here + /// UnknownSection { id, .. } => { /* ... */ } + /// + /// // Once we've reached the end of a parser we either resume + /// // at the parent parser or we break out of the loop because + /// // we're done. + /// End(_) => { + /// if let Some(parent_parser) = stack.pop() { + /// parser = parent_parser; + /// } else { + /// break; + /// } + /// } + /// } + /// + /// // once we're done processing the payload we can forget the + /// // original. + /// buf.drain(..consumed); + /// } + /// + /// Ok(()) + /// } + /// + /// # parse(&b"\0asm\x01\0\0\0"[..]).unwrap(); + /// ``` + pub fn parse<'a>(&mut self, data: &'a [u8], eof: bool) -> Result> { + let (data, eof) = if usize_to_u64(data.len()) > self.max_size { + (&data[..(self.max_size as usize)], true) + } else { + (data, eof) + }; + // TODO: thread through `offset: u64` to `BinaryReader`, remove + // the cast here. + let mut reader = BinaryReader::new_with_offset(data, self.offset as usize); + match self.parse_reader(&mut reader, eof) { + Ok(payload) => { + // Be sure to update our offset with how far we got in the + // reader + self.offset += usize_to_u64(reader.position); + self.max_size -= usize_to_u64(reader.position); + Ok(Chunk::Parsed { + consumed: reader.position, + payload, + }) + } + Err(e) => { + // If we're at EOF then there's no way we can recover from any + // error, so continue to propagate it. + if eof { + return Err(e); + } + + // If our error doesn't look like it can be resolved with more + // data being pulled down, then propagate it, otherwise switch + // the error to "feed me please" + match e.inner.needed_hint { + Some(hint) => Ok(Chunk::NeedMoreData(usize_to_u64(hint))), + None => Err(e), + } + } + } + } + + fn parse_reader<'a>( + &mut self, + reader: &mut BinaryReader<'a>, + eof: bool, + ) -> Result> { + use Payload::*; + + match self.state { + State::Header => { + let start = reader.original_position(); + let num = reader.read_header_version()?; + self.encoding = match num { + WASM_EXPERIMENTAL_VERSION | WASM_MODULE_VERSION => Encoding::Module, + WASM_COMPONENT_VERSION => Encoding::Component, + _ => { + return Err(BinaryReaderError::new( + "unknown binary version", + reader.original_position() - 4, + )) + } + }; + self.state = State::SectionStart; + Ok(Version { + num, + encoding: self.encoding, + range: start..reader.original_position(), + }) + } + State::SectionStart => { + // If we're at eof and there are no bytes in our buffer, then + // that means we reached the end of the data since it's + // just a bunch of sections concatenated after the header. + if eof && reader.bytes_remaining() == 0 { + return Ok(Payload::End(reader.original_position())); + } + + let id_pos = reader.position; + let id = reader.read_u8()?; + if id & 0x80 != 0 { + return Err(BinaryReaderError::new("malformed section id", id_pos)); + } + let len_pos = reader.position; + let mut len = reader.read_var_u32()?; + + // Test to make sure that this section actually fits within + // `Parser::max_size`. This doesn't matter for top-level modules + // but it is required for nested modules/components to correctly ensure + // that all sections live entirely within their section of the + // file. + let section_overflow = self + .max_size + .checked_sub(usize_to_u64(reader.position)) + .and_then(|s| s.checked_sub(len.into())) + .is_none(); + if section_overflow { + return Err(BinaryReaderError::new("section too large", len_pos)); + } + + // Check for custom sections (supported by all encodings) + if id == 0 {} + + match (self.encoding, id) { + // Sections for both modules and components. + (_, 0) => section(reader, len, CustomSectionReader::new, CustomSection), + + // Module sections + (Encoding::Module, 1) => { + section(reader, len, TypeSectionReader::new, TypeSection) + } + (Encoding::Module, 2) => { + section(reader, len, ImportSectionReader::new, ImportSection) + } + (Encoding::Module, 3) => { + section(reader, len, FunctionSectionReader::new, FunctionSection) + } + (Encoding::Module, 4) => { + section(reader, len, TableSectionReader::new, TableSection) + } + (Encoding::Module, 5) => { + section(reader, len, MemorySectionReader::new, MemorySection) + } + (Encoding::Module, 6) => { + section(reader, len, GlobalSectionReader::new, GlobalSection) + } + (Encoding::Module, 7) => { + section(reader, len, ExportSectionReader::new, ExportSection) + } + (Encoding::Module, 8) => { + let (func, range) = single_u32(reader, len, "start")?; + Ok(StartSection { func, range }) + } + (Encoding::Module, 9) => { + section(reader, len, ElementSectionReader::new, ElementSection) + } + (Encoding::Module, 10) => { + let start = reader.original_position(); + let count = delimited(reader, &mut len, |r| r.read_var_u32())?; + let range = start..reader.original_position() + len as usize; + self.state = State::FunctionBody { + remaining: count, + len, + }; + Ok(CodeSectionStart { + count, + range, + size: len, + }) + } + (Encoding::Module, 11) => { + section(reader, len, DataSectionReader::new, DataSection) + } + (Encoding::Module, 12) => { + let (count, range) = single_u32(reader, len, "data count")?; + Ok(DataCountSection { count, range }) + } + (Encoding::Module, 13) => { + section(reader, len, TagSectionReader::new, TagSection) + } + + // Component sections + (Encoding::Component, 1 /* module */) + | (Encoding::Component, 5 /* component */) => { + if len as usize > MAX_WASM_MODULE_SIZE { + return Err(BinaryReaderError::new( + format!( + "{} section is too large", + if id == 1 { "module" } else { "component " } + ), + len_pos, + )); + } + + let range = + reader.original_position()..reader.original_position() + len as usize; + self.max_size -= u64::from(len); + self.offset += u64::from(len); + let mut parser = Parser::new(usize_to_u64(reader.original_position())); + parser.max_size = len.into(); + + Ok(match id { + 1 => ModuleSection { parser, range }, + 5 => ComponentSection { parser, range }, + _ => unreachable!(), + }) + } + (Encoding::Component, 2) => { + section(reader, len, InstanceSectionReader::new, InstanceSection) + } + (Encoding::Component, 3) => { + section(reader, len, AliasSectionReader::new, AliasSection) + } + (Encoding::Component, 4) => { + section(reader, len, CoreTypeSectionReader::new, CoreTypeSection) + } + // Section 5 handled above + (Encoding::Component, 6) => section( + reader, + len, + ComponentInstanceSectionReader::new, + ComponentInstanceSection, + ), + (Encoding::Component, 7) => section( + reader, + len, + ComponentAliasSectionReader::new, + ComponentAliasSection, + ), + (Encoding::Component, 8) => section( + reader, + len, + ComponentTypeSectionReader::new, + ComponentTypeSection, + ), + (Encoding::Component, 9) => section( + reader, + len, + ComponentCanonicalSectionReader::new, + ComponentCanonicalSection, + ), + (Encoding::Component, 10) => section( + reader, + len, + ComponentStartSectionReader::new, + ComponentStartSection, + ), + (Encoding::Component, 11) => section( + reader, + len, + ComponentImportSectionReader::new, + ComponentImportSection, + ), + (Encoding::Component, 12) => section( + reader, + len, + ComponentExportSectionReader::new, + ComponentExportSection, + ), + (_, id) => { + let offset = reader.original_position(); + let contents = reader.read_bytes(len as usize)?; + let range = offset..offset + len as usize; + Ok(UnknownSection { + id, + contents, + range, + }) + } + } + } + + // Once we hit 0 remaining incrementally parsed items, with 0 + // remaining bytes in each section, we're done and can switch back + // to parsing sections. + State::FunctionBody { + remaining: 0, + len: 0, + } => { + self.state = State::SectionStart; + self.parse_reader(reader, eof) + } + + // ... otherwise trailing bytes with no remaining entries in these + // sections indicates an error. + State::FunctionBody { remaining: 0, len } => { + debug_assert!(len > 0); + let offset = reader.original_position(); + Err(BinaryReaderError::new( + "trailing bytes at end of section", + offset, + )) + } + + // Functions are relatively easy to parse when we know there's at + // least one remaining and at least one byte available to read + // things. + // + // We use the remaining length try to read a u32 size of the + // function, and using that size we require the entire function be + // resident in memory. This means that we're reading whole chunks of + // functions at a time. + // + // Limiting via `Parser::max_size` (nested parsing) happens above in + // `fn parse`, and limiting by our section size happens via + // `delimited`. Actual parsing of the function body is delegated to + // the caller to iterate over the `FunctionBody` structure. + State::FunctionBody { remaining, mut len } => { + let body = delimited(reader, &mut len, |r| { + let size = r.read_var_u32()?; + let offset = r.original_position(); + Ok(FunctionBody::new(offset, r.read_bytes(size as usize)?)) + })?; + self.state = State::FunctionBody { + remaining: remaining - 1, + len, + }; + Ok(CodeSectionEntry(body)) + } + } + } + + /// Convenience function that can be used to parse a module or component + /// that is entirely resident in memory. + /// + /// This function will parse the `data` provided as a WebAssembly module + /// or component. + /// + /// Note that when this function yields sections that provide parsers, + /// no further action is required for those sections as payloads from + /// those parsers will be automatically returned. + pub fn parse_all(self, mut data: &[u8]) -> impl Iterator> { + let mut stack = Vec::new(); + let mut cur = self; + let mut done = false; + iter::from_fn(move || { + if done { + return None; + } + let payload = match cur.parse(data, true) { + // Propagate all errors + Err(e) => { + done = true; + return Some(Err(e)); + } + + // This isn't possible because `eof` is always true. + Ok(Chunk::NeedMoreData(_)) => unreachable!(), + + Ok(Chunk::Parsed { payload, consumed }) => { + data = &data[consumed..]; + payload + } + }; + + match &payload { + Payload::ModuleSection { parser, .. } + | Payload::ComponentSection { parser, .. } => { + stack.push(cur.clone()); + cur = parser.clone(); + } + Payload::End(_) => match stack.pop() { + Some(p) => cur = p, + None => done = true, + }, + + _ => {} + } + + Some(Ok(payload)) + }) + } + + /// Skip parsing the code section entirely. + /// + /// This function can be used to indicate, after receiving + /// `CodeSectionStart`, that the section will not be parsed. + /// + /// The caller will be responsible for skipping `size` bytes (found in the + /// `CodeSectionStart` payload). Bytes should only be fed into `parse` + /// after the `size` bytes have been skipped. + /// + /// # Panics + /// + /// This function will panic if the parser is not in a state where it's + /// parsing the code section. + /// + /// # Examples + /// + /// ``` + /// use wasmparser::{Result, Parser, Chunk, SectionReader, Payload::*}; + /// use std::ops::Range; + /// + /// fn objdump_headers(mut wasm: &[u8]) -> Result<()> { + /// let mut parser = Parser::new(0); + /// loop { + /// let payload = match parser.parse(wasm, true)? { + /// Chunk::Parsed { consumed, payload } => { + /// wasm = &wasm[consumed..]; + /// payload + /// } + /// // this state isn't possible with `eof = true` + /// Chunk::NeedMoreData(_) => unreachable!(), + /// }; + /// match payload { + /// TypeSection(s) => print_range("type section", &s.range()), + /// ImportSection(s) => print_range("import section", &s.range()), + /// // .. other sections + /// + /// // Print the range of the code section we see, but don't + /// // actually iterate over each individual function. + /// CodeSectionStart { range, size, .. } => { + /// print_range("code section", &range); + /// parser.skip_section(); + /// wasm = &wasm[size as usize..]; + /// } + /// End(_) => break, + /// _ => {} + /// } + /// } + /// Ok(()) + /// } + /// + /// fn print_range(section: &str, range: &Range) { + /// println!("{:>40}: {:#010x} - {:#010x}", section, range.start, range.end); + /// } + /// ``` + pub fn skip_section(&mut self) { + let skip = match self.state { + State::FunctionBody { remaining: _, len } => len, + _ => panic!("wrong state to call `skip_section`"), + }; + self.offset += u64::from(skip); + self.max_size -= u64::from(skip); + self.state = State::SectionStart; + } +} + +fn usize_to_u64(a: usize) -> u64 { + a.try_into().unwrap() +} + +/// Parses an entire section resident in memory into a `Payload`. +/// +/// Requires that `len` bytes are resident in `reader` and uses `ctor`/`variant` +/// to construct the section to return. +fn section<'a, T>( + reader: &mut BinaryReader<'a>, + len: u32, + ctor: fn(&'a [u8], usize) -> Result, + variant: fn(T) -> Payload<'a>, +) -> Result> { + let offset = reader.original_position(); + let payload = reader.read_bytes(len as usize)?; + // clear the hint for "need this many more bytes" here because we already + // read all the bytes, so it's not possible to read more bytes if this + // fails. + let reader = ctor(payload, offset).map_err(clear_hint)?; + Ok(variant(reader)) +} + +/// Creates a new `BinaryReader` from the given `reader` which will be reading +/// the first `len` bytes. +/// +/// This means that `len` bytes must be resident in memory at the time of this +/// reading. +fn subreader<'a>(reader: &mut BinaryReader<'a>, len: u32) -> Result> { + let offset = reader.original_position(); + let payload = reader.read_bytes(len as usize)?; + Ok(BinaryReader::new_with_offset(payload, offset)) +} + +/// Reads a section that is represented by a single uleb-encoded `u32`. +fn single_u32<'a>( + reader: &mut BinaryReader<'a>, + len: u32, + desc: &str, +) -> Result<(u32, Range)> { + let range = reader.original_position()..reader.original_position() + len as usize; + let mut content = subreader(reader, len)?; + // We can't recover from "unexpected eof" here because our entire section is + // already resident in memory, so clear the hint for how many more bytes are + // expected. + let index = content.read_var_u32().map_err(clear_hint)?; + if !content.eof() { + return Err(BinaryReaderError::new( + format!("unexpected content in the {} section", desc), + content.original_position(), + )); + } + Ok((index, range)) +} + +/// Attempts to parse using `f`. +/// +/// This will update `*len` with the number of bytes consumed, and it will cause +/// a failure to be returned instead of the number of bytes consumed exceeds +/// what `*len` currently is. +fn delimited<'a, T>( + reader: &mut BinaryReader<'a>, + len: &mut u32, + f: impl FnOnce(&mut BinaryReader<'a>) -> Result, +) -> Result { + let start = reader.position; + let ret = f(reader)?; + *len = match (reader.position - start) + .try_into() + .ok() + .and_then(|i| len.checked_sub(i)) + { + Some(i) => i, + None => return Err(BinaryReaderError::new("unexpected end-of-file", start)), + }; + Ok(ret) +} + +impl Default for Parser { + fn default() -> Parser { + Parser::new(0) + } +} + +impl fmt::Debug for Payload<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + use Payload::*; + match self { + Version { + num, + encoding, + range, + } => f + .debug_struct("Version") + .field("num", num) + .field("encoding", encoding) + .field("range", range) + .finish(), + + // Module sections + TypeSection(_) => f.debug_tuple("TypeSection").field(&"...").finish(), + ImportSection(_) => f.debug_tuple("ImportSection").field(&"...").finish(), + FunctionSection(_) => f.debug_tuple("FunctionSection").field(&"...").finish(), + TableSection(_) => f.debug_tuple("TableSection").field(&"...").finish(), + MemorySection(_) => f.debug_tuple("MemorySection").field(&"...").finish(), + TagSection(_) => f.debug_tuple("TagSection").field(&"...").finish(), + GlobalSection(_) => f.debug_tuple("GlobalSection").field(&"...").finish(), + ExportSection(_) => f.debug_tuple("ExportSection").field(&"...").finish(), + ElementSection(_) => f.debug_tuple("ElementSection").field(&"...").finish(), + DataSection(_) => f.debug_tuple("DataSection").field(&"...").finish(), + StartSection { func, range } => f + .debug_struct("StartSection") + .field("func", func) + .field("range", range) + .finish(), + DataCountSection { count, range } => f + .debug_struct("DataCountSection") + .field("count", count) + .field("range", range) + .finish(), + CodeSectionStart { count, range, size } => f + .debug_struct("CodeSectionStart") + .field("count", count) + .field("range", range) + .field("size", size) + .finish(), + CodeSectionEntry(_) => f.debug_tuple("CodeSectionEntry").field(&"...").finish(), + + // Component sections + ModuleSection { parser: _, range } => f + .debug_struct("ModuleSection") + .field("range", range) + .finish(), + InstanceSection(_) => f.debug_tuple("InstanceSection").field(&"...").finish(), + AliasSection(_) => f.debug_tuple("AliasSection").field(&"...").finish(), + CoreTypeSection(_) => f.debug_tuple("CoreTypeSection").field(&"...").finish(), + ComponentSection { parser: _, range } => f + .debug_struct("ComponentSection") + .field("range", range) + .finish(), + ComponentInstanceSection(_) => f + .debug_tuple("ComponentInstanceSection") + .field(&"...") + .finish(), + ComponentAliasSection(_) => f + .debug_tuple("ComponentAliasSection") + .field(&"...") + .finish(), + ComponentTypeSection(_) => f.debug_tuple("ComponentTypeSection").field(&"...").finish(), + ComponentCanonicalSection(_) => f + .debug_tuple("ComponentCanonicalSection") + .field(&"...") + .finish(), + ComponentStartSection(_) => f + .debug_tuple("ComponentStartSection") + .field(&"...") + .finish(), + ComponentImportSection(_) => f + .debug_tuple("ComponentImportSection") + .field(&"...") + .finish(), + ComponentExportSection(_) => f + .debug_tuple("ComponentExportSection") + .field(&"...") + .finish(), + + CustomSection(c) => f.debug_tuple("CustomSection").field(c).finish(), + + UnknownSection { id, range, .. } => f + .debug_struct("UnknownSection") + .field("id", id) + .field("range", range) + .finish(), + + End(offset) => f.debug_tuple("End").field(offset).finish(), + } + } +} + +fn clear_hint(mut err: BinaryReaderError) -> BinaryReaderError { + err.inner.needed_hint = None; + err +} + +#[cfg(test)] +mod tests { + use super::*; + + macro_rules! assert_matches { + ($a:expr, $b:pat $(,)?) => { + match $a { + $b => {} + a => panic!("`{:?}` doesn't match `{}`", a, stringify!($b)), + } + }; + } + + #[test] + fn header() { + assert!(Parser::default().parse(&[], true).is_err()); + assert_matches!( + Parser::default().parse(&[], false), + Ok(Chunk::NeedMoreData(4)), + ); + assert_matches!( + Parser::default().parse(b"\0", false), + Ok(Chunk::NeedMoreData(3)), + ); + assert_matches!( + Parser::default().parse(b"\0asm", false), + Ok(Chunk::NeedMoreData(4)), + ); + assert_matches!( + Parser::default().parse(b"\0asm\x01\0\0\0", false), + Ok(Chunk::Parsed { + consumed: 8, + payload: Payload::Version { num: 1, .. }, + }), + ); + } + + #[test] + fn header_iter() { + for _ in Parser::default().parse_all(&[]) {} + for _ in Parser::default().parse_all(b"\0") {} + for _ in Parser::default().parse_all(b"\0asm") {} + for _ in Parser::default().parse_all(b"\0asm\x01\x01\x01\x01") {} + } + + fn parser_after_header() -> Parser { + let mut p = Parser::default(); + assert_matches!( + p.parse(b"\0asm\x01\0\0\0", false), + Ok(Chunk::Parsed { + consumed: 8, + payload: Payload::Version { + num: WASM_MODULE_VERSION, + encoding: Encoding::Module, + .. + }, + }), + ); + p + } + + fn parser_after_component_header() -> Parser { + let mut p = Parser::default(); + assert_matches!( + p.parse(b"\0asm\x0a\0\x01\0", false), + Ok(Chunk::Parsed { + consumed: 8, + payload: Payload::Version { + num: WASM_COMPONENT_VERSION, + encoding: Encoding::Component, + .. + }, + }), + ); + p + } + + #[test] + fn start_section() { + assert_matches!( + parser_after_header().parse(&[], false), + Ok(Chunk::NeedMoreData(1)), + ); + assert!(parser_after_header().parse(&[8], true).is_err()); + assert!(parser_after_header().parse(&[8, 1], true).is_err()); + assert!(parser_after_header().parse(&[8, 2], true).is_err()); + assert_matches!( + parser_after_header().parse(&[8], false), + Ok(Chunk::NeedMoreData(1)), + ); + assert_matches!( + parser_after_header().parse(&[8, 1], false), + Ok(Chunk::NeedMoreData(1)), + ); + assert_matches!( + parser_after_header().parse(&[8, 2], false), + Ok(Chunk::NeedMoreData(2)), + ); + assert_matches!( + parser_after_header().parse(&[8, 1, 1], false), + Ok(Chunk::Parsed { + consumed: 3, + payload: Payload::StartSection { func: 1, .. }, + }), + ); + assert!(parser_after_header().parse(&[8, 2, 1, 1], false).is_err()); + assert!(parser_after_header().parse(&[8, 0], false).is_err()); + } + + #[test] + fn end_works() { + assert_matches!( + parser_after_header().parse(&[], true), + Ok(Chunk::Parsed { + consumed: 0, + payload: Payload::End(8), + }), + ); + } + + #[test] + fn type_section() { + assert!(parser_after_header().parse(&[1], true).is_err()); + assert!(parser_after_header().parse(&[1, 0], false).is_err()); + assert!(parser_after_header().parse(&[8, 2], true).is_err()); + assert_matches!( + parser_after_header().parse(&[1], false), + Ok(Chunk::NeedMoreData(1)), + ); + assert_matches!( + parser_after_header().parse(&[1, 1], false), + Ok(Chunk::NeedMoreData(1)), + ); + assert_matches!( + parser_after_header().parse(&[1, 1, 1], false), + Ok(Chunk::Parsed { + consumed: 3, + payload: Payload::TypeSection(_), + }), + ); + assert_matches!( + parser_after_header().parse(&[1, 1, 1, 2, 3, 4], false), + Ok(Chunk::Parsed { + consumed: 3, + payload: Payload::TypeSection(_), + }), + ); + } + + #[test] + fn custom_section() { + assert!(parser_after_header().parse(&[0], true).is_err()); + assert!(parser_after_header().parse(&[0, 0], false).is_err()); + assert!(parser_after_header().parse(&[0, 1, 1], false).is_err()); + assert_matches!( + parser_after_header().parse(&[0, 2, 1], false), + Ok(Chunk::NeedMoreData(1)), + ); + assert_matches!( + parser_after_header().parse(&[0, 1, 0], false), + Ok(Chunk::Parsed { + consumed: 3, + payload: Payload::CustomSection(CustomSectionReader { + name: "", + data_offset: 11, + data: b"", + range: Range { start: 10, end: 11 }, + }), + }), + ); + assert_matches!( + parser_after_header().parse(&[0, 2, 1, b'a'], false), + Ok(Chunk::Parsed { + consumed: 4, + payload: Payload::CustomSection(CustomSectionReader { + name: "a", + data_offset: 12, + data: b"", + range: Range { start: 10, end: 12 }, + }), + }), + ); + assert_matches!( + parser_after_header().parse(&[0, 2, 0, b'a'], false), + Ok(Chunk::Parsed { + consumed: 4, + payload: Payload::CustomSection(CustomSectionReader { + name: "", + data_offset: 11, + data: b"a", + range: Range { start: 10, end: 12 }, + }), + }), + ); + } + + #[test] + fn function_section() { + assert!(parser_after_header().parse(&[10], true).is_err()); + assert!(parser_after_header().parse(&[10, 0], true).is_err()); + assert!(parser_after_header().parse(&[10, 1], true).is_err()); + assert_matches!( + parser_after_header().parse(&[10], false), + Ok(Chunk::NeedMoreData(1)) + ); + assert_matches!( + parser_after_header().parse(&[10, 1], false), + Ok(Chunk::NeedMoreData(1)) + ); + let mut p = parser_after_header(); + assert_matches!( + p.parse(&[10, 1, 0], false), + Ok(Chunk::Parsed { + consumed: 3, + payload: Payload::CodeSectionStart { count: 0, .. }, + }), + ); + assert_matches!( + p.parse(&[], true), + Ok(Chunk::Parsed { + consumed: 0, + payload: Payload::End(11), + }), + ); + let mut p = parser_after_header(); + assert_matches!( + p.parse(&[10, 2, 1, 0], false), + Ok(Chunk::Parsed { + consumed: 3, + payload: Payload::CodeSectionStart { count: 1, .. }, + }), + ); + assert_matches!( + p.parse(&[0], false), + Ok(Chunk::Parsed { + consumed: 1, + payload: Payload::CodeSectionEntry(_), + }), + ); + assert_matches!( + p.parse(&[], true), + Ok(Chunk::Parsed { + consumed: 0, + payload: Payload::End(12), + }), + ); + + // 1 byte section with 1 function can't read the function body because + // the section is too small + let mut p = parser_after_header(); + assert_matches!( + p.parse(&[10, 1, 1], false), + Ok(Chunk::Parsed { + consumed: 3, + payload: Payload::CodeSectionStart { count: 1, .. }, + }), + ); + assert_eq!( + p.parse(&[0], false).unwrap_err().message(), + "unexpected end-of-file" + ); + + // section with 2 functions but section is cut off + let mut p = parser_after_header(); + assert_matches!( + p.parse(&[10, 2, 2], false), + Ok(Chunk::Parsed { + consumed: 3, + payload: Payload::CodeSectionStart { count: 2, .. }, + }), + ); + assert_matches!( + p.parse(&[0], false), + Ok(Chunk::Parsed { + consumed: 1, + payload: Payload::CodeSectionEntry(_), + }), + ); + assert_matches!(p.parse(&[], false), Ok(Chunk::NeedMoreData(1))); + assert_eq!( + p.parse(&[0], false).unwrap_err().message(), + "unexpected end-of-file", + ); + + // trailing data is bad + let mut p = parser_after_header(); + assert_matches!( + p.parse(&[10, 3, 1], false), + Ok(Chunk::Parsed { + consumed: 3, + payload: Payload::CodeSectionStart { count: 1, .. }, + }), + ); + assert_matches!( + p.parse(&[0], false), + Ok(Chunk::Parsed { + consumed: 1, + payload: Payload::CodeSectionEntry(_), + }), + ); + assert_eq!( + p.parse(&[0], false).unwrap_err().message(), + "trailing bytes at end of section", + ); + } + + #[test] + fn single_module() { + let mut p = parser_after_component_header(); + assert_matches!(p.parse(&[4], false), Ok(Chunk::NeedMoreData(1))); + + // A module that's 8 bytes in length + let mut sub = match p.parse(&[1, 8], false) { + Ok(Chunk::Parsed { + consumed: 2, + payload: Payload::ModuleSection { parser, .. }, + }) => parser, + other => panic!("bad parse {:?}", other), + }; + + // Parse the header of the submodule with the sub-parser. + assert_matches!(sub.parse(&[], false), Ok(Chunk::NeedMoreData(4))); + assert_matches!(sub.parse(b"\0asm", false), Ok(Chunk::NeedMoreData(4))); + assert_matches!( + sub.parse(b"\0asm\x01\0\0\0", false), + Ok(Chunk::Parsed { + consumed: 8, + payload: Payload::Version { + num: 1, + encoding: Encoding::Module, + .. + }, + }), + ); + + // The sub-parser should be byte-limited so the next byte shouldn't get + // consumed, it's intended for the parent parser. + assert_matches!( + sub.parse(&[10], false), + Ok(Chunk::Parsed { + consumed: 0, + payload: Payload::End(18), + }), + ); + + // The parent parser should now be back to resuming, and we simulate it + // being done with bytes to ensure that it's safely at the end, + // completing the module code section. + assert_matches!(p.parse(&[], false), Ok(Chunk::NeedMoreData(1))); + assert_matches!( + p.parse(&[], true), + Ok(Chunk::Parsed { + consumed: 0, + payload: Payload::End(18), + }), + ); + } + + #[test] + fn nested_section_too_big() { + let mut p = parser_after_component_header(); + + // A module that's 10 bytes in length + let mut sub = match p.parse(&[1, 10], false) { + Ok(Chunk::Parsed { + consumed: 2, + payload: Payload::ModuleSection { parser, .. }, + }) => parser, + other => panic!("bad parse {:?}", other), + }; + + // use 8 bytes to parse the header, leaving 2 remaining bytes in our + // module. + assert_matches!( + sub.parse(b"\0asm\x01\0\0\0", false), + Ok(Chunk::Parsed { + consumed: 8, + payload: Payload::Version { num: 1, .. }, + }), + ); + + // We can't parse a section which declares its bigger than the outer + // module. This is a custom section, one byte big, with one content byte. The + // content byte, however, lives outside of the parent's module code + // section. + assert_eq!( + sub.parse(&[0, 1, 0], false).unwrap_err().message(), + "section too large", + ); + } +} diff --git a/crates/wasmparser/src/readers.rs b/crates/wasmparser/src/readers.rs new file mode 100644 index 000000000..32c455630 --- /dev/null +++ b/crates/wasmparser/src/readers.rs @@ -0,0 +1,152 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{BinaryReaderError, Result}; +use std::ops::Range; + +mod component; +mod core; + +pub use self::component::*; +pub use self::core::*; + +/// A trait implemented by section readers. +pub trait SectionReader { + /// The item returned by the reader. + type Item; + + /// Reads an item from the section. + fn read(&mut self) -> Result; + + /// Determines if the reader is at end-of-section. + fn eof(&self) -> bool; + + /// Gets the original position of the reader. + fn original_position(&self) -> usize; + + /// Gets the range of the reader. + fn range(&self) -> Range; + + /// Ensures the reader is at the end of the section. + /// + /// This methods returns an error if there is more data in the section + /// than what is described by the section's header. + fn ensure_end(&self) -> Result<()> { + if self.eof() { + return Ok(()); + } + Err(BinaryReaderError::new( + "section size mismatch: unexpected data at the end of the section", + self.original_position(), + )) + } +} + +/// Implemented by sections with a limited number of items. +pub trait SectionWithLimitedItems { + /// Gets the count of the items in the section. + fn get_count(&self) -> u32; +} + +/// An iterator over items in a section. +pub struct SectionIterator +where + R: SectionReader, +{ + reader: R, + err: bool, +} + +impl SectionIterator +where + R: SectionReader, +{ + /// Constructs a new `SectionIterator` for the given section reader. + pub fn new(reader: R) -> SectionIterator { + SectionIterator { reader, err: false } + } +} + +impl Iterator for SectionIterator +where + R: SectionReader, +{ + type Item = Result; + + fn next(&mut self) -> Option { + if self.err || self.reader.eof() { + return None; + } + let result = self.reader.read(); + self.err = result.is_err(); + Some(result) + } +} + +/// An iterator over a limited section iterator. +pub struct SectionIteratorLimited +where + R: SectionReader + SectionWithLimitedItems, +{ + reader: R, + left: u32, + end: bool, +} + +impl SectionIteratorLimited +where + R: SectionReader + SectionWithLimitedItems, +{ + /// Constructs a new `SectionIteratorLimited` for the given limited section reader. + pub fn new(reader: R) -> SectionIteratorLimited { + let left = reader.get_count(); + SectionIteratorLimited { + reader, + left, + end: false, + } + } +} + +impl Iterator for SectionIteratorLimited +where + R: SectionReader + SectionWithLimitedItems, +{ + type Item = Result; + + fn next(&mut self) -> Option { + if self.end { + return None; + } + if self.left == 0 { + return match self.reader.ensure_end() { + Ok(()) => None, + Err(err) => { + self.end = true; + Some(Err(err)) + } + }; + } + let result = self.reader.read(); + self.end = result.is_err(); + self.left -= 1; + Some(result) + } + + fn size_hint(&self) -> (usize, Option) { + let count = self.reader.get_count() as usize; + (count, Some(count)) + } +} diff --git a/crates/wasmparser/src/readers/component.rs b/crates/wasmparser/src/readers/component.rs new file mode 100644 index 000000000..268b264cc --- /dev/null +++ b/crates/wasmparser/src/readers/component.rs @@ -0,0 +1,15 @@ +mod aliases; +mod canonicals; +mod exports; +mod imports; +mod instances; +mod start; +mod types; + +pub use self::aliases::*; +pub use self::canonicals::*; +pub use self::exports::*; +pub use self::imports::*; +pub use self::instances::*; +pub use self::start::*; +pub use self::types::*; diff --git a/crates/wasmparser/src/readers/component/aliases.rs b/crates/wasmparser/src/readers/component/aliases.rs new file mode 100644 index 000000000..1cab5888c --- /dev/null +++ b/crates/wasmparser/src/readers/component/aliases.rs @@ -0,0 +1,225 @@ +use crate::{ + BinaryReader, ComponentExternalKind, ExternalKind, Result, SectionIteratorLimited, + SectionReader, SectionWithLimitedItems, +}; +use std::ops::Range; + +/// Represents the kind of an outer core alias in a WebAssembly component. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum OuterAliasKind { + /// The alias is to a core type. + Type, +} + +/// Represents a core alias for a WebAssembly module. +#[derive(Debug, Clone)] +pub enum Alias<'a> { + /// The alias is to an export of a module instance. + InstanceExport { + /// The alias kind. + kind: ExternalKind, + /// The instance index. + instance_index: u32, + /// The export name. + name: &'a str, + }, + /// The alias is to an outer item. + Outer { + /// The alias kind. + kind: OuterAliasKind, + /// The outward count, starting at zero for the current component. + count: u32, + /// The index of the item within the outer component. + index: u32, + }, +} + +/// A reader for the core alias section of a WebAssembly component. +#[derive(Clone)] +pub struct AliasSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> AliasSectionReader<'a> { + /// Constructs a new `AliasSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(Self { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the core alias section. + /// + /// # Examples + /// ``` + /// use wasmparser::AliasSectionReader; + /// let data: &[u8] = &[0x01, 0x00, 0x00, 0x00, 0x03, b'f', b'o', b'o']; + /// let mut reader = AliasSectionReader::new(data, 0).unwrap(); + /// for _ in 0..reader.get_count() { + /// let alias = reader.read().expect("alias"); + /// println!("Alias: {:?}", alias); + /// } + /// ``` + pub fn read(&mut self) -> Result> { + self.reader.read_alias() + } +} + +impl<'a> SectionReader for AliasSectionReader<'a> { + type Item = Alias<'a>; + + fn read(&mut self) -> Result { + Self::read(self) + } + + fn eof(&self) -> bool { + self.reader.eof() + } + + fn original_position(&self) -> usize { + Self::original_position(self) + } + + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for AliasSectionReader<'a> { + fn get_count(&self) -> u32 { + Self::get_count(self) + } +} + +impl<'a> IntoIterator for AliasSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIteratorLimited; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} + +/// Represents the kind of an outer alias in a WebAssembly component. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum ComponentOuterAliasKind { + /// The alias is to a core module. + CoreModule, + /// The alias is to a core type. + CoreType, + /// The alias is to a component type. + Type, + /// The alias is to a component. + Component, +} + +/// Represents an alias in a WebAssembly component. +#[derive(Debug, Clone)] +pub enum ComponentAlias<'a> { + /// The alias is to an export of a component instance. + InstanceExport { + /// The alias kind. + kind: ComponentExternalKind, + /// The instance index. + instance_index: u32, + /// The export name. + name: &'a str, + }, + /// The alias is to an outer item. + Outer { + /// The alias kind. + kind: ComponentOuterAliasKind, + /// The outward count, starting at zero for the current component. + count: u32, + /// The index of the item within the outer component. + index: u32, + }, +} + +/// A reader for the alias section of a WebAssembly component. +#[derive(Clone)] +pub struct ComponentAliasSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> ComponentAliasSectionReader<'a> { + /// Constructs a new `ComponentAliasSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(Self { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the alias section. + /// + /// # Examples + /// ``` + /// use wasmparser::ComponentAliasSectionReader; + /// let data: &[u8] = &[0x01, 0x01, 0x00, 0x00, 0x03, b'f', b'o', b'o']; + /// let mut reader = ComponentAliasSectionReader::new(data, 0).unwrap(); + /// for _ in 0..reader.get_count() { + /// let alias = reader.read().expect("alias"); + /// println!("Alias: {:?}", alias); + /// } + /// ``` + pub fn read(&mut self) -> Result> { + self.reader.read_component_alias() + } +} + +impl<'a> SectionReader for ComponentAliasSectionReader<'a> { + type Item = ComponentAlias<'a>; + + fn read(&mut self) -> Result { + Self::read(self) + } + + fn eof(&self) -> bool { + self.reader.eof() + } + + fn original_position(&self) -> usize { + Self::original_position(self) + } + + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for ComponentAliasSectionReader<'a> { + fn get_count(&self) -> u32 { + Self::get_count(self) + } +} + +impl<'a> IntoIterator for ComponentAliasSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIteratorLimited; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/component/canonicals.rs b/crates/wasmparser/src/readers/component/canonicals.rs new file mode 100644 index 000000000..321e63fad --- /dev/null +++ b/crates/wasmparser/src/readers/component/canonicals.rs @@ -0,0 +1,124 @@ +use crate::{BinaryReader, Result, SectionIteratorLimited, SectionReader, SectionWithLimitedItems}; +use std::ops::Range; + +/// Represents options for component functions. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum CanonicalOption { + /// The string types in the function signature are UTF-8 encoded. + UTF8, + /// The string types in the function signature are UTF-16 encoded. + UTF16, + /// The string types in the function signature are compact UTF-16 encoded. + CompactUTF16, + /// The memory to use if the lifting or lowering of a function requires memory access. + /// + /// The value is an index to a core memory. + Memory(u32), + /// The realloc function to use if the lifting or lowering of a function requires memory + /// allocation. + /// + /// The value is an index to a core function of type `(func (param i32 i32 i32 i32) (result i32))`. + Realloc(u32), + /// The post-return function to use if the lifting of a function requires + /// cleanup after the function returns. + PostReturn(u32), +} + +/// Represents a canonical function in a WebAssembly component. +#[derive(Debug, Clone)] +pub enum CanonicalFunction { + /// The function lifts a core WebAssembly function to the canonical ABI. + Lift { + /// The index of the core WebAssembly function to lift. + core_func_index: u32, + /// The index of the lifted function's type. + type_index: u32, + /// The canonical options for the function. + options: Box<[CanonicalOption]>, + }, + /// The function lowers a canonical ABI function to a core WebAssembly function. + Lower { + /// The index of the function to lower. + func_index: u32, + /// The canonical options for the function. + options: Box<[CanonicalOption]>, + }, +} + +/// A reader for the canonical section of a WebAssembly component. +#[derive(Clone)] +pub struct ComponentCanonicalSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> ComponentCanonicalSectionReader<'a> { + /// Constructs a new `ComponentFunctionSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(Self { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads function type index from the function section. + /// + /// # Examples + /// + /// ``` + /// use wasmparser::ComponentCanonicalSectionReader; + /// # let data: &[u8] = &[0x01, 0x00, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00]; + /// let mut reader = ComponentCanonicalSectionReader::new(data, 0).unwrap(); + /// for _ in 0..reader.get_count() { + /// let func = reader.read().expect("func"); + /// println!("Function: {:?}", func); + /// } + /// ``` + pub fn read(&mut self) -> Result { + self.reader.read_canonical_func() + } +} + +impl<'a> SectionReader for ComponentCanonicalSectionReader<'a> { + type Item = CanonicalFunction; + + fn read(&mut self) -> Result { + Self::read(self) + } + + fn eof(&self) -> bool { + self.reader.eof() + } + + fn original_position(&self) -> usize { + Self::original_position(self) + } + + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for ComponentCanonicalSectionReader<'a> { + fn get_count(&self) -> u32 { + Self::get_count(self) + } +} + +impl<'a> IntoIterator for ComponentCanonicalSectionReader<'a> { + type Item = Result; + type IntoIter = SectionIteratorLimited; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/component/exports.rs b/crates/wasmparser/src/readers/component/exports.rs new file mode 100644 index 000000000..dc08131c3 --- /dev/null +++ b/crates/wasmparser/src/readers/component/exports.rs @@ -0,0 +1,108 @@ +use crate::{BinaryReader, Result, SectionIteratorLimited, SectionReader, SectionWithLimitedItems}; +use std::ops::Range; + +/// Represents the kind of an external items of a WebAssembly component. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum ComponentExternalKind { + /// The external kind is a core module. + Module, + /// The external kind is a function. + Func, + /// The external kind is a value. + Value, + /// The external kind is a type. + Type, + /// The external kind is an instance. + Instance, + /// The external kind is a component. + Component, +} + +/// Represents an export in a WebAssembly component. +#[derive(Debug, Clone)] +pub struct ComponentExport<'a> { + /// The name of the exported item. + pub name: &'a str, + /// The kind of the export. + pub kind: ComponentExternalKind, + /// The index of the exported item. + pub index: u32, +} + +/// A reader for the export section of a WebAssembly component. +#[derive(Clone)] +pub struct ComponentExportSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> ComponentExportSectionReader<'a> { + /// Constructs a new `ComponentExportSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(Self { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the export section. + /// + /// # Examples + /// ``` + /// use wasmparser::ComponentExportSectionReader; + /// + /// # let data: &[u8] = &[0x01, 0x03, b'f', b'o', b'o', 0x01, 0x00]; + /// let mut reader = ComponentExportSectionReader::new(data, 0).unwrap(); + /// for _ in 0..reader.get_count() { + /// let export = reader.read().expect("export"); + /// println!("Export: {:?}", export); + /// } + /// ``` + pub fn read(&mut self) -> Result> { + self.reader.read_component_export() + } +} + +impl<'a> SectionReader for ComponentExportSectionReader<'a> { + type Item = ComponentExport<'a>; + + fn read(&mut self) -> Result { + Self::read(self) + } + + fn eof(&self) -> bool { + self.reader.eof() + } + + fn original_position(&self) -> usize { + Self::original_position(self) + } + + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for ComponentExportSectionReader<'a> { + fn get_count(&self) -> u32 { + Self::get_count(self) + } +} + +impl<'a> IntoIterator for ComponentExportSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIteratorLimited; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/component/imports.rs b/crates/wasmparser/src/readers/component/imports.rs new file mode 100644 index 000000000..0b7b4faf8 --- /dev/null +++ b/crates/wasmparser/src/readers/component/imports.rs @@ -0,0 +1,125 @@ +use crate::{ + BinaryReader, ComponentValType, Result, SectionIteratorLimited, SectionReader, + SectionWithLimitedItems, +}; +use std::ops::Range; + +/// Represents the type bounds for imports and exports. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum TypeBounds { + /// The type is bounded by equality. + Eq, +} + +/// Represents a reference to a component type. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum ComponentTypeRef { + /// The reference is to a core module type. + /// + /// The index is expected to be core type index to a core module type. + Module(u32), + /// The reference is to a function type. + /// + /// The index is expected to be a type index to a function type. + Func(u32), + /// The reference is to a value type. + Value(ComponentValType), + /// The reference is to a bounded type. + /// + /// The index is expected to be a type index. + Type(TypeBounds, u32), + /// The reference is to an instance type. + /// + /// The index is a type index to an instance type. + Instance(u32), + /// The reference is to a component type. + /// + /// The index is a type index to a component type. + Component(u32), +} + +/// Represents an import in a WebAssembly component +#[derive(Debug, Copy, Clone)] +pub struct ComponentImport<'a> { + /// The name of the imported item. + pub name: &'a str, + /// The type reference for the import. + pub ty: ComponentTypeRef, +} + +/// A reader for the import section of a WebAssembly component. +#[derive(Clone)] +pub struct ComponentImportSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> ComponentImportSectionReader<'a> { + /// Constructs a new `ComponentImportSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(Self { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the import section. + /// + /// # Examples + /// ``` + /// use wasmparser::ComponentImportSectionReader; + /// let data: &[u8] = &[0x01, 0x01, 0x41, 0x01, 0x66, 0x00, 0x00]; + /// let mut reader = ComponentImportSectionReader::new(data, 0).unwrap(); + /// for _ in 0..reader.get_count() { + /// let import = reader.read().expect("import"); + /// println!("Import: {:?}", import); + /// } + /// ``` + pub fn read(&mut self) -> Result> { + self.reader.read_component_import() + } +} + +impl<'a> SectionReader for ComponentImportSectionReader<'a> { + type Item = ComponentImport<'a>; + + fn read(&mut self) -> Result { + Self::read(self) + } + + fn eof(&self) -> bool { + self.reader.eof() + } + + fn original_position(&self) -> usize { + Self::original_position(self) + } + + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for ComponentImportSectionReader<'a> { + fn get_count(&self) -> u32 { + Self::get_count(self) + } +} + +impl<'a> IntoIterator for ComponentImportSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIteratorLimited; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/component/instances.rs b/crates/wasmparser/src/readers/component/instances.rs new file mode 100644 index 000000000..79cacfbe9 --- /dev/null +++ b/crates/wasmparser/src/readers/component/instances.rs @@ -0,0 +1,240 @@ +use crate::{ + BinaryReader, ComponentExport, ComponentExternalKind, Export, Result, SectionIteratorLimited, + SectionReader, SectionWithLimitedItems, +}; +use std::ops::Range; + +/// Represents the kind of an instantiation argument for a core instance. +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum InstantiationArgKind { + /// The instantiation argument is a core instance. + Instance, +} + +/// Represents an argument to instantiating a WebAssembly module. +#[derive(Debug, Clone)] +pub struct InstantiationArg<'a> { + /// The name of the module argument. + pub name: &'a str, + /// The kind of the module argument. + pub kind: InstantiationArgKind, + /// The index of the argument item. + pub index: u32, +} + +/// Represents an instance of a WebAssembly module. +#[derive(Debug, Clone)] +pub enum Instance<'a> { + /// The instance is from instantiating a WebAssembly module. + Instantiate { + /// The module index. + module_index: u32, + /// The module's instantiation arguments. + args: Box<[InstantiationArg<'a>]>, + }, + /// The instance is a from exporting local items. + FromExports(Box<[Export<'a>]>), +} + +/// A reader for the core instance section of a WebAssembly component. +#[derive(Clone)] +pub struct InstanceSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> InstanceSectionReader<'a> { + /// Constructs a new `InstanceSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(Self { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the instance section. + /// + /// # Examples + /// ``` + /// use wasmparser::InstanceSectionReader; + /// # let data: &[u8] = &[0x01, 0x00, 0x00, 0x01, 0x03, b'f', b'o', b'o', 0x12, 0x00]; + /// let mut reader = InstanceSectionReader::new(data, 0).unwrap(); + /// for _ in 0..reader.get_count() { + /// let instance = reader.read().expect("instance"); + /// println!("Instance: {:?}", instance); + /// } + /// ``` + pub fn read(&mut self) -> Result> { + self.reader.read_instance() + } +} + +impl<'a> SectionReader for InstanceSectionReader<'a> { + type Item = Instance<'a>; + + fn read(&mut self) -> Result { + Self::read(self) + } + + fn eof(&self) -> bool { + self.reader.eof() + } + + fn original_position(&self) -> usize { + Self::original_position(self) + } + + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for InstanceSectionReader<'a> { + fn get_count(&self) -> u32 { + Self::get_count(self) + } +} + +impl<'a> IntoIterator for InstanceSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIteratorLimited; + + /// Implements iterator over the instance section. + /// + /// # Examples + /// + /// ``` + /// use wasmparser::InstanceSectionReader; + /// # let data: &[u8] = &[0x01, 0x00, 0x00, 0x01, 0x03, b'f', b'o', b'o', 0x12, 0x00]; + /// let mut reader = InstanceSectionReader::new(data, 0).unwrap(); + /// for inst in reader { + /// println!("Instance {:?}", inst.expect("instance")); + /// } + /// ``` + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} + +/// Represents an argument to instantiating a WebAssembly component. +#[derive(Debug, Clone)] +pub struct ComponentInstantiationArg<'a> { + /// The name of the component argument. + pub name: &'a str, + /// The kind of the component argument. + pub kind: ComponentExternalKind, + /// The index of the argument item. + pub index: u32, +} + +/// Represents an instance in a WebAssembly component. +#[derive(Debug, Clone)] +pub enum ComponentInstance<'a> { + /// The instance is from instantiating a WebAssembly component. + Instantiate { + /// The component index. + component_index: u32, + /// The component's instantiation arguments. + args: Box<[ComponentInstantiationArg<'a>]>, + }, + /// The instance is a from exporting local items. + FromExports(Box<[ComponentExport<'a>]>), +} + +/// A reader for the component instance section of a WebAssembly component. +#[derive(Clone)] +pub struct ComponentInstanceSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> ComponentInstanceSectionReader<'a> { + /// Constructs a new `ComponentInstanceSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(Self { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the instance section. + /// + /// # Examples + /// ``` + /// use wasmparser::ComponentInstanceSectionReader; + /// # let data: &[u8] = &[0x01, 0x00, 0x00, 0x01, 0x03, b'f', b'o', b'o', 0x01, 0x00]; + /// let mut reader = ComponentInstanceSectionReader::new(data, 0).unwrap(); + /// for _ in 0..reader.get_count() { + /// let instance = reader.read().expect("instance"); + /// println!("Instance: {:?}", instance); + /// } + /// ``` + pub fn read(&mut self) -> Result> { + self.reader.read_component_instance() + } +} + +impl<'a> SectionReader for ComponentInstanceSectionReader<'a> { + type Item = ComponentInstance<'a>; + + fn read(&mut self) -> Result { + Self::read(self) + } + + fn eof(&self) -> bool { + self.reader.eof() + } + + fn original_position(&self) -> usize { + Self::original_position(self) + } + + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for ComponentInstanceSectionReader<'a> { + fn get_count(&self) -> u32 { + Self::get_count(self) + } +} + +impl<'a> IntoIterator for ComponentInstanceSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIteratorLimited; + + /// Implements iterator over the instance section. + /// + /// # Examples + /// + /// ``` + /// use wasmparser::ComponentInstanceSectionReader; + /// # let data: &[u8] = &[0x01, 0x00, 0x00, 0x01, 0x03, b'f', b'o', b'o', 0x01, 0x00]; + /// let mut reader = ComponentInstanceSectionReader::new(data, 0).unwrap(); + /// for inst in reader { + /// println!("Instance {:?}", inst.expect("instance")); + /// } + /// ``` + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/component/start.rs b/crates/wasmparser/src/readers/component/start.rs new file mode 100644 index 000000000..743139271 --- /dev/null +++ b/crates/wasmparser/src/readers/component/start.rs @@ -0,0 +1,64 @@ +use crate::{BinaryReader, Result, SectionReader}; +use std::ops::Range; + +/// Represents the start function in a WebAssembly component. +#[derive(Debug, Clone)] +pub struct ComponentStartFunction { + /// The index to the start function. + pub func_index: u32, + /// The start function arguments. + /// + /// The arguments are specified by value index. + pub arguments: Box<[u32]>, +} + +/// A reader for the start section of a WebAssembly component. +#[derive(Clone)] +pub struct ComponentStartSectionReader<'a>(BinaryReader<'a>); + +impl<'a> ComponentStartSectionReader<'a> { + /// Constructs a new `ComponentStartSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result { + Ok(Self(BinaryReader::new_with_offset(data, offset))) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.0.original_position() + } + + /// Reads the start function from the section. + /// + /// # Examples + /// ``` + /// use wasmparser::ComponentStartSectionReader; + /// + /// # let data: &[u8] = &[0x00, 0x03, 0x01, 0x02, 0x03]; + /// let mut reader = ComponentStartSectionReader::new(data, 0).unwrap(); + /// let start = reader.read().expect("start"); + /// println!("Start: {:?}", start); + /// ``` + pub fn read(&mut self) -> Result { + self.0.read_component_start() + } +} + +impl<'a> SectionReader for ComponentStartSectionReader<'a> { + type Item = ComponentStartFunction; + + fn read(&mut self) -> Result { + Self::read(self) + } + + fn eof(&self) -> bool { + self.0.eof() + } + + fn original_position(&self) -> usize { + Self::original_position(self) + } + + fn range(&self) -> Range { + self.0.range() + } +} diff --git a/crates/wasmparser/src/readers/component/types.rs b/crates/wasmparser/src/readers/component/types.rs new file mode 100644 index 000000000..b2ea1d7cc --- /dev/null +++ b/crates/wasmparser/src/readers/component/types.rs @@ -0,0 +1,437 @@ +use crate::{ + Alias, BinaryReader, ComponentAlias, ComponentImport, ComponentTypeRef, FuncType, Import, + Result, SectionIteratorLimited, SectionReader, SectionWithLimitedItems, Type, TypeRef, +}; +use std::ops::Range; + +/// Represents a core type in a WebAssembly component. +#[derive(Debug, Clone)] +pub enum CoreType<'a> { + /// The type is for a core function. + Func(FuncType), + /// The type is for a core module. + Module(Box<[ModuleTypeDeclaration<'a>]>), +} + +/// Represents a module type declaration in a WebAssembly component. +#[derive(Debug, Clone)] +pub enum ModuleTypeDeclaration<'a> { + /// The module type definition is for a type. + Type(Type), + /// The module type definition is for an export. + Export { + /// The name of the exported item. + name: &'a str, + /// The type reference of the export. + ty: TypeRef, + }, + /// The module type declaration is for an alias. + Alias(Alias<'a>), + /// The module type definition is for an import. + Import(Import<'a>), +} + +/// A reader for the core type section of a WebAssembly component. +#[derive(Clone)] +pub struct CoreTypeSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> CoreTypeSectionReader<'a> { + /// Constructs a new `CoreTypeSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(Self { reader, count }) + } + + /// Gets the original position of the reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets a count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the type section. + /// + /// # Examples + /// ``` + /// use wasmparser::CoreTypeSectionReader; + /// let data: &[u8] = &[0x01, 0x60, 0x00, 0x00]; + /// let mut reader = CoreTypeSectionReader::new(data, 0).unwrap(); + /// for _ in 0..reader.get_count() { + /// let ty = reader.read().expect("type"); + /// println!("Type {:?}", ty); + /// } + /// ``` + pub fn read(&mut self) -> Result> { + self.reader.read_core_type() + } +} + +impl<'a> SectionReader for CoreTypeSectionReader<'a> { + type Item = CoreType<'a>; + + fn read(&mut self) -> Result { + Self::read(self) + } + + fn eof(&self) -> bool { + self.reader.eof() + } + + fn original_position(&self) -> usize { + Self::original_position(self) + } + + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for CoreTypeSectionReader<'a> { + fn get_count(&self) -> u32 { + Self::get_count(self) + } +} + +impl<'a> IntoIterator for CoreTypeSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIteratorLimited; + + /// Implements iterator over the type section. + /// + /// # Examples + /// ``` + /// use wasmparser::CoreTypeSectionReader; + /// # let data: &[u8] = &[0x01, 0x60, 0x00, 0x00]; + /// let mut reader = CoreTypeSectionReader::new(data, 0).unwrap(); + /// for ty in reader { + /// println!("Type {:?}", ty.expect("type")); + /// } + /// ``` + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} + +/// Represents a value type in a WebAssembly component. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum ComponentValType { + /// The value type is a primitive type. + Primitive(PrimitiveValType), + /// The value type is a reference to a defined type. + Type(u32), +} + +/// Represents a primitive value type. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum PrimitiveValType { + /// The type is a boolean. + Bool, + /// The type is a signed 8-bit integer. + S8, + /// The type is an unsigned 8-bit integer. + U8, + /// The type is a signed 16-bit integer. + S16, + /// The type is an unsigned 16-bit integer. + U16, + /// The type is a signed 32-bit integer. + S32, + /// The type is an unsigned 32-bit integer. + U32, + /// The type is a signed 64-bit integer. + S64, + /// The type is an unsigned 64-bit integer. + U64, + /// The type is a 32-bit floating point number. + Float32, + /// The type is a 64-bit floating point number. + Float64, + /// The type is a Unicode character. + Char, + /// The type is a string. + String, +} + +impl PrimitiveValType { + pub(crate) fn requires_realloc(&self) -> bool { + matches!(self, Self::String) + } + + /// Determines if primitive value type `a` is a subtype of `b`. + pub fn is_subtype_of(a: Self, b: Self) -> bool { + // Subtyping rules according to + // https://github.com/WebAssembly/component-model/blob/17f94ed1270a98218e0e796ca1dad1feb7e5c507/design/mvp/Subtyping.md + a == b + || matches!( + (a, b), + (Self::S8, Self::S16) + | (Self::S8, Self::S32) + | (Self::S8, Self::S64) + | (Self::U8, Self::U16) + | (Self::U8, Self::U32) + | (Self::U8, Self::U64) + | (Self::U8, Self::S16) + | (Self::U8, Self::S32) + | (Self::U8, Self::S64) + | (Self::S16, Self::S32) + | (Self::S16, Self::S64) + | (Self::U16, Self::U32) + | (Self::U16, Self::U64) + | (Self::U16, Self::S32) + | (Self::U16, Self::S64) + | (Self::S32, Self::S64) + | (Self::U32, Self::U64) + | (Self::U32, Self::S64) + | (Self::Float32, Self::Float64) + ) + } +} + +/// Represents a type in a WebAssembly component. +#[derive(Debug, Clone)] +pub enum ComponentType<'a> { + /// The type is a component defined type. + Defined(ComponentDefinedType<'a>), + /// The type is a function type. + Func(ComponentFuncType<'a>), + /// The type is a component type. + Component(Box<[ComponentTypeDeclaration<'a>]>), + /// The type is an instance type. + Instance(Box<[InstanceTypeDeclaration<'a>]>), +} + +/// Represents part of a component type declaration in a WebAssembly component. +#[derive(Debug, Clone)] +pub enum ComponentTypeDeclaration<'a> { + /// The component type declaration is for a core type. + CoreType(CoreType<'a>), + /// The component type declaration is for a type. + Type(ComponentType<'a>), + /// The component type declaration is for an alias. + Alias(ComponentAlias<'a>), + /// The component type declaration is for an export. + Export { + /// The name of the export. + name: &'a str, + /// The type reference for the export. + ty: ComponentTypeRef, + }, + /// The component type declaration is for an import. + Import(ComponentImport<'a>), +} + +/// Represents an instance type declaration in a WebAssembly component. +#[derive(Debug, Clone)] +pub enum InstanceTypeDeclaration<'a> { + /// The component type declaration is for a core type. + CoreType(CoreType<'a>), + /// The instance type declaration is for a type. + Type(ComponentType<'a>), + /// The instance type declaration is for an alias. + Alias(ComponentAlias<'a>), + /// The instance type declaration is for an export. + Export { + /// The name of the export. + name: &'a str, + /// The type reference for the export. + ty: ComponentTypeRef, + }, +} + +/// Represents the vector of types in a component function's +/// parameters or results. +#[derive(Debug, Clone)] +pub enum TypeVec<'a> { + /// The type vector contains a single, unnamed type. + Unnamed(ComponentValType), + /// The type vector contains zero or more named types. + Named(Box<[(&'a str, ComponentValType)]>), +} + +impl TypeVec<'_> { + /// Gets the type vector's length. + pub fn len(&self) -> usize { + match self { + Self::Unnamed(_) => 1, + Self::Named(vec) => vec.len(), + } + } + + /// Determines if the type vector is empty. + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Iterates over the types in the type vector. + pub fn iter(&self) -> impl Iterator, &ComponentValType)> { + enum Either { + Left(L), + Right(R), + } + + impl Iterator for Either + where + L: Iterator, + R: Iterator, + { + type Item = L::Item; + + fn next(&mut self) -> Option { + match self { + Either::Left(l) => l.next(), + Either::Right(r) => r.next(), + } + } + } + + match self { + Self::Unnamed(ty) => Either::Left(std::iter::once(ty).map(|ty| (None, ty))), + Self::Named(vec) => Either::Right(vec.iter().map(|(n, ty)| (Some(*n), ty))), + } + } +} + +/// Represents a type of a function in a WebAssembly component. +#[derive(Debug, Clone)] +pub struct ComponentFuncType<'a> { + /// The function parameters. + pub params: TypeVec<'a>, + /// The function results. + pub results: TypeVec<'a>, +} + +/// Represents a case in a variant type. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct VariantCase<'a> { + /// The name of the variant case. + pub name: &'a str, + /// The value type of the variant case. + pub ty: Option, + /// The index of the variant case that is refined by this one. + pub refines: Option, +} + +/// Represents a defined type in a WebAssembly component. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ComponentDefinedType<'a> { + /// The type is one of the primitive value types. + Primitive(PrimitiveValType), + /// The type is a record with the given fields. + Record(Box<[(&'a str, ComponentValType)]>), + /// The type is a variant with the given cases. + Variant(Box<[VariantCase<'a>]>), + /// The type is a list of the given value type. + List(ComponentValType), + /// The type is a tuple of the given value types. + Tuple(Box<[ComponentValType]>), + /// The type is flags with the given names. + Flags(Box<[&'a str]>), + /// The type is an enum with the given tags. + Enum(Box<[&'a str]>), + /// The type is a union of the given value types. + Union(Box<[ComponentValType]>), + /// The type is an option of the given value type. + Option(ComponentValType), + /// The type is a result type. + Result { + /// The type returned for success. + ok: Option, + /// The type returned for failure. + err: Option, + }, +} + +/// A reader for the type section of a WebAssembly component. +#[derive(Clone)] +pub struct ComponentTypeSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> ComponentTypeSectionReader<'a> { + /// Constructs a new `ComponentTypeSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(Self { reader, count }) + } + + /// Gets the original position of the reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets a count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the type section. + /// + /// # Examples + /// ``` + /// use wasmparser::ComponentTypeSectionReader; + /// let data: &[u8] = &[0x01, 0x40, 0x01, 0x01, 0x03, b'f', b'o', b'o', 0x73, 0x00, 0x73]; + /// let mut reader = ComponentTypeSectionReader::new(data, 0).unwrap(); + /// for _ in 0..reader.get_count() { + /// let ty = reader.read().expect("type"); + /// println!("Type {:?}", ty); + /// } + /// ``` + pub fn read(&mut self) -> Result> { + self.reader.read_component_type() + } +} + +impl<'a> SectionReader for ComponentTypeSectionReader<'a> { + type Item = ComponentType<'a>; + + fn read(&mut self) -> Result { + Self::read(self) + } + + fn eof(&self) -> bool { + self.reader.eof() + } + + fn original_position(&self) -> usize { + Self::original_position(self) + } + + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for ComponentTypeSectionReader<'a> { + fn get_count(&self) -> u32 { + Self::get_count(self) + } +} + +impl<'a> IntoIterator for ComponentTypeSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIteratorLimited; + + /// Implements iterator over the type section. + /// + /// # Examples + /// ``` + /// use wasmparser::ComponentTypeSectionReader; + /// let data: &[u8] = &[0x01, 0x40, 0x01, 0x01, 0x03, b'f', b'o', b'o', 0x73, 0x00, 0x73]; + /// let mut reader = ComponentTypeSectionReader::new(data, 0).unwrap(); + /// for ty in reader { + /// println!("Type {:?}", ty.expect("type")); + /// } + /// ``` + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/core.rs b/crates/wasmparser/src/readers/core.rs new file mode 100644 index 000000000..941f20854 --- /dev/null +++ b/crates/wasmparser/src/readers/core.rs @@ -0,0 +1,37 @@ +mod code; +mod custom; +mod data; +mod elements; +mod exports; +mod functions; +mod globals; +mod imports; +mod init; +mod linking; +mod memories; +mod names; +mod operators; +mod producers; +mod relocs; +mod tables; +mod tags; +mod types; + +pub use self::code::*; +pub use self::custom::*; +pub use self::data::*; +pub use self::elements::*; +pub use self::exports::*; +pub use self::functions::*; +pub use self::globals::*; +pub use self::imports::*; +pub use self::init::*; +pub use self::linking::*; +pub use self::memories::*; +pub use self::names::*; +pub use self::operators::*; +pub use self::producers::*; +pub use self::relocs::*; +pub use self::tables::*; +pub use self::tags::*; +pub use self::types::*; diff --git a/crates/wasmparser/src/readers/core/code.rs b/crates/wasmparser/src/readers/core/code.rs new file mode 100644 index 000000000..500e3ad18 --- /dev/null +++ b/crates/wasmparser/src/readers/core/code.rs @@ -0,0 +1,270 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{ + BinaryReader, BinaryReaderError, OperatorsReader, Result, SectionIteratorLimited, + SectionReader, SectionWithLimitedItems, ValType, +}; +use std::ops::Range; + +/// Represents a WebAssembly function body. +#[derive(Debug, Clone, Copy)] +pub struct FunctionBody<'a> { + offset: usize, + data: &'a [u8], + allow_memarg64: bool, +} + +impl<'a> FunctionBody<'a> { + /// Constructs a new `FunctionBody` for the given data and offset. + pub fn new(offset: usize, data: &'a [u8]) -> Self { + Self { + offset, + data, + allow_memarg64: false, + } + } + + /// Whether or not to allow 64-bit memory arguments in the + /// function body. + /// + /// This is intended to be `true` when support for the memory64 + /// WebAssembly proposal is also enabled. + pub fn allow_memarg64(&mut self, allow: bool) { + self.allow_memarg64 = allow; + } + + /// Gets a binary reader for this function body. + pub fn get_binary_reader<'b>(&self) -> BinaryReader<'b> + where + 'a: 'b, + { + let mut reader = BinaryReader::new_with_offset(self.data, self.offset); + reader.allow_memarg64(self.allow_memarg64); + reader + } + + fn skip_locals(reader: &mut BinaryReader) -> Result<()> { + let count = reader.read_var_u32()?; + for _ in 0..count { + reader.read_var_u32()?; + reader.read_var_u32()?; + } + Ok(()) + } + + /// Gets the locals reader for this function body. + pub fn get_locals_reader<'b>(&self) -> Result> + where + 'a: 'b, + { + let mut reader = BinaryReader::new_with_offset(self.data, self.offset); + let count = reader.read_var_u32()?; + Ok(LocalsReader { reader, count }) + } + + /// Gets the operators reader for this function body. + pub fn get_operators_reader<'b>(&self) -> Result> + where + 'a: 'b, + { + let mut reader = BinaryReader::new_with_offset(self.data, self.offset); + Self::skip_locals(&mut reader)?; + let pos = reader.position; + let mut reader = OperatorsReader::new(&self.data[pos..], self.offset + pos); + reader.allow_memarg64(self.allow_memarg64); + Ok(reader) + } + + /// Gets the range of the function body. + pub fn range(&self) -> Range { + self.offset..self.offset + self.data.len() + } +} + +/// A reader for a function body's locals. +pub struct LocalsReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> LocalsReader<'a> { + /// Gets the count of locals in the function body. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Gets the original position of the reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Reads an item from the reader. + pub fn read(&mut self) -> Result<(u32, ValType)> { + let count = self.reader.read_var_u32()?; + let value_type = self.reader.read_val_type()?; + Ok((count, value_type)) + } +} + +impl<'a> IntoIterator for LocalsReader<'a> { + type Item = Result<(u32, ValType)>; + type IntoIter = LocalsIterator<'a>; + fn into_iter(self) -> Self::IntoIter { + let count = self.count; + LocalsIterator { + reader: self, + left: count, + err: false, + } + } +} + +/// An iterator over locals in a function body. +pub struct LocalsIterator<'a> { + reader: LocalsReader<'a>, + left: u32, + err: bool, +} + +impl<'a> Iterator for LocalsIterator<'a> { + type Item = Result<(u32, ValType)>; + fn next(&mut self) -> Option { + if self.err || self.left == 0 { + return None; + } + let result = self.reader.read(); + self.err = result.is_err(); + self.left -= 1; + Some(result) + } + fn size_hint(&self) -> (usize, Option) { + let count = self.reader.get_count() as usize; + (count, Some(count)) + } +} + +/// A reader for the code section of a WebAssembly module. +pub struct CodeSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> CodeSectionReader<'a> { + /// Constructs a new `CodeSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result> { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(CodeSectionReader { reader, count }) + } + + /// Gets the original position of the reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + fn verify_body_end(&self, end: usize) -> Result<()> { + if self.reader.buffer.len() < end { + return Err(BinaryReaderError::new( + "function body extends past end of the code section", + self.reader.original_offset + self.reader.buffer.len(), + )); + } + Ok(()) + } + + /// Reads content of the code section. + /// + /// # Examples + /// ``` + /// use wasmparser::CodeSectionReader; + /// # let data: &[u8] = &[ + /// # 0x01, 0x03, 0x00, 0x01, 0x0b]; + /// let mut code_reader = CodeSectionReader::new(data, 0).unwrap(); + /// for _ in 0..code_reader.get_count() { + /// let body = code_reader.read().expect("function body"); + /// let mut binary_reader = body.get_binary_reader(); + /// assert!(binary_reader.read_var_u32().expect("local count") == 0); + /// let op = binary_reader.read_operator().expect("first operator"); + /// println!("First operator: {:?}", op); + /// } + /// ``` + pub fn read<'b>(&mut self) -> Result> + where + 'a: 'b, + { + let size = self.reader.read_var_u32()? as usize; + let body_start = self.reader.position; + let body_end = body_start + size; + self.verify_body_end(body_end)?; + self.reader.skip_to(body_end); + Ok(FunctionBody { + offset: self.reader.original_offset + body_start, + data: &self.reader.buffer[body_start..body_end], + allow_memarg64: false, + }) + } +} + +impl<'a> SectionReader for CodeSectionReader<'a> { + type Item = FunctionBody<'a>; + fn read(&mut self) -> Result { + CodeSectionReader::read(self) + } + fn eof(&self) -> bool { + self.reader.eof() + } + fn original_position(&self) -> usize { + CodeSectionReader::original_position(self) + } + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for CodeSectionReader<'a> { + fn get_count(&self) -> u32 { + CodeSectionReader::get_count(self) + } +} + +impl<'a> IntoIterator for CodeSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIteratorLimited>; + + /// Implements iterator over the code section. + /// + /// # Examples + /// ``` + /// use wasmparser::CodeSectionReader; + /// # let data: &[u8] = &[ + /// # 0x01, 0x03, 0x00, 0x01, 0x0b]; + /// let mut code_reader = CodeSectionReader::new(data, 0).unwrap(); + /// for body in code_reader { + /// let mut binary_reader = body.expect("b").get_binary_reader(); + /// assert!(binary_reader.read_var_u32().expect("local count") == 0); + /// let op = binary_reader.read_operator().expect("first operator"); + /// println!("First operator: {:?}", op); + /// } + /// ``` + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/core/custom.rs b/crates/wasmparser/src/readers/core/custom.rs new file mode 100644 index 000000000..a04fe5a1a --- /dev/null +++ b/crates/wasmparser/src/readers/core/custom.rs @@ -0,0 +1,63 @@ +use crate::{BinaryReader, Result}; +use std::ops::Range; + +/// A reader for custom sections of a WebAssembly module. +#[derive(Clone)] +pub struct CustomSectionReader<'a> { + // NB: these fields are public to the crate to make testing easier. + pub(crate) name: &'a str, + pub(crate) data_offset: usize, + pub(crate) data: &'a [u8], + pub(crate) range: Range, +} + +impl<'a> CustomSectionReader<'a> { + /// Constructs a new `CustomSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result> { + let mut reader = BinaryReader::new_with_offset(data, offset); + let name = reader.read_string()?; + let data_offset = reader.original_position(); + let data = reader.remaining_buffer(); + let range = reader.range(); + Ok(CustomSectionReader { + name, + data_offset, + data, + range, + }) + } + + /// The name of the custom section. + pub fn name(&self) -> &'a str { + self.name + } + + /// The offset, relative to the start of the original module or component, + /// that the `data` payload for this custom section starts at. + pub fn data_offset(&self) -> usize { + self.data_offset + } + + /// The actual contents of the custom section. + pub fn data(&self) -> &'a [u8] { + self.data + } + + /// The range of bytes that specify this whole custom section (including + /// both the name of this custom section and its data) specified in + /// offsets relative to the start of the byte stream. + pub fn range(&self) -> Range { + self.range.clone() + } +} + +impl<'a> std::fmt::Debug for CustomSectionReader<'a> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("CustomSectionReader") + .field("name", &self.name) + .field("data_offset", &self.data_offset) + .field("data", &"...") + .field("range", &self.range) + .finish() + } +} diff --git a/crates/wasmparser/src/readers/core/data.rs b/crates/wasmparser/src/readers/core/data.rs new file mode 100644 index 000000000..8843f1aa5 --- /dev/null +++ b/crates/wasmparser/src/readers/core/data.rs @@ -0,0 +1,189 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{ + BinaryReader, BinaryReaderError, ConstExpr, Result, SectionIteratorLimited, SectionReader, + SectionWithLimitedItems, +}; +use std::ops::Range; + +/// Represents a data segment in a core WebAssembly module. +#[derive(Debug, Clone)] +pub struct Data<'a> { + /// The kind of data segment. + pub kind: DataKind<'a>, + /// The data of the data segment. + pub data: &'a [u8], + /// The range of the data segment. + pub range: Range, +} + +/// The kind of data segment. +#[derive(Debug, Copy, Clone)] +pub enum DataKind<'a> { + /// The data segment is passive. + Passive, + /// The data segment is active. + Active { + /// The memory index for the data segment. + memory_index: u32, + /// The initialization expression for the data segment. + offset_expr: ConstExpr<'a>, + }, +} + +/// A reader for the data section of a WebAssembly module. +#[derive(Clone)] +pub struct DataSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> DataSectionReader<'a> { + /// Constructs a new `DataSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result> { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(DataSectionReader { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + fn verify_data_end(&self, end: usize) -> Result<()> { + if self.reader.buffer.len() < end { + return Err(BinaryReaderError::new( + "unexpected end of section or function: data segment extends past end of the data section", + self.reader.original_offset + self.reader.buffer.len(), + )); + } + Ok(()) + } + + /// Reads content of the data section. + /// + /// # Examples + /// ``` + /// use wasmparser::{DataSectionReader, DataKind}; + /// # let data: &[u8] = &[ + /// # 0x01, 0x00, 0x41, 0x80, 0x08, 0x0b, 0x04, 0x00, 0x00, 0x00, 0x00]; + /// let mut data_reader = DataSectionReader::new(data, 0).unwrap(); + /// for _ in 0..data_reader.get_count() { + /// let data = data_reader.read().expect("data"); + /// println!("Data: {:?}", data); + /// if let DataKind::Active { offset_expr, .. } = data.kind { + /// let mut offset_expr_reader = offset_expr.get_binary_reader(); + /// let op = offset_expr_reader.read_operator().expect("op"); + /// println!("offset expression: {:?}", op); + /// } + /// } + /// ``` + pub fn read<'b>(&mut self) -> Result> + where + 'a: 'b, + { + let segment_start = self.reader.original_position(); + + // The current handling of the flags is largely specified in the `bulk-memory` proposal, + // which at the time this commend is written has been merged to the main specification + // draft. + // + // Notably, this proposal allows multiple different encodings of the memory index 0. `00` + // and `02 00` are both valid ways to specify the 0-th memory. However it also makes + // another encoding of the 0-th memory `80 00` no longer valid. + // + // We, however maintain this by parsing `flags` as a LEB128 integer. In that case, `80 00` + // encoding is parsed out as `0` and is therefore assigned a `memidx` 0, even though the + // current specification draft does not allow for this. + // + // See also https://github.com/WebAssembly/spec/issues/1439 + let flags = self.reader.read_var_u32()?; + let kind = match flags { + 1 => DataKind::Passive, + 0 | 2 => { + let memory_index = if flags == 0 { + 0 + } else { + self.reader.read_var_u32()? + }; + let offset_expr = { + let expr_offset = self.reader.position; + self.reader.skip_const_expr()?; + let data = &self.reader.buffer[expr_offset..self.reader.position]; + ConstExpr::new(data, self.reader.original_offset + expr_offset) + }; + DataKind::Active { + memory_index, + offset_expr, + } + } + _ => { + return Err(BinaryReaderError::new( + "invalid flags byte in data segment", + self.reader.original_position() - 1, + )); + } + }; + + let data_len = self.reader.read_var_u32()? as usize; + let data_end = self.reader.position + data_len; + self.verify_data_end(data_end)?; + let data = &self.reader.buffer[self.reader.position..data_end]; + self.reader.skip_to(data_end); + + let segment_end = self.reader.original_position(); + let range = segment_start..segment_end; + + Ok(Data { kind, data, range }) + } +} + +impl<'a> SectionReader for DataSectionReader<'a> { + type Item = Data<'a>; + fn read(&mut self) -> Result { + DataSectionReader::read(self) + } + fn eof(&self) -> bool { + self.reader.eof() + } + fn original_position(&self) -> usize { + DataSectionReader::original_position(self) + } + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for DataSectionReader<'a> { + fn get_count(&self) -> u32 { + DataSectionReader::get_count(self) + } +} + +impl<'a> IntoIterator for DataSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIteratorLimited>; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/core/elements.rs b/crates/wasmparser/src/readers/core/elements.rs new file mode 100644 index 000000000..3eb0735d4 --- /dev/null +++ b/crates/wasmparser/src/readers/core/elements.rs @@ -0,0 +1,333 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{ + BinaryReader, BinaryReaderError, ConstExpr, ExternalKind, Result, SectionIteratorLimited, + SectionReader, SectionWithLimitedItems, ValType, +}; +use std::ops::Range; + +/// Represents a core WebAssembly element segment. +#[derive(Clone)] +pub struct Element<'a> { + /// The kind of the element segment. + pub kind: ElementKind<'a>, + /// The initial elements of the element segment. + pub items: ElementItems<'a>, + /// The type of the elements. + pub ty: ValType, + /// The range of the the element segment. + pub range: Range, +} + +/// The kind of element segment. +#[derive(Clone)] +pub enum ElementKind<'a> { + /// The element segment is passive. + Passive, + /// The element segment is active. + Active { + /// The index of the table being initialized. + table_index: u32, + /// The initial expression of the element segment. + offset_expr: ConstExpr<'a>, + }, + /// The element segment is declared. + Declared, +} + +/// Represents the items of an element segment. +#[derive(Debug, Copy, Clone)] +pub struct ElementItems<'a> { + exprs: bool, + offset: usize, + data: &'a [u8], +} + +/// Represents an individual item of an element segment. +#[derive(Debug)] +pub enum ElementItem<'a> { + /// The item is a function index. + Func(u32), + /// The item is an initialization expression. + Expr(ConstExpr<'a>), +} + +impl<'a> ElementItems<'a> { + /// Gets an items reader for the items in an element segment. + pub fn get_items_reader<'b>(&self) -> Result> + where + 'a: 'b, + { + ElementItemsReader::new(self.data, self.offset, self.exprs) + } +} + +/// A reader for element items in an element segment. +pub struct ElementItemsReader<'a> { + reader: BinaryReader<'a>, + count: u32, + exprs: bool, +} + +impl<'a> ElementItemsReader<'a> { + /// Constructs a new `ElementItemsReader` for the given data and offset. + pub fn new(data: &[u8], offset: usize, exprs: bool) -> Result { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(ElementItemsReader { + reader, + count, + exprs, + }) + } + + /// Gets the original position of the reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of element items in the segment. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Whether or not initialization expressions are used. + pub fn uses_exprs(&self) -> bool { + self.exprs + } + + /// Reads an element item from the segment. + pub fn read(&mut self) -> Result> { + if self.exprs { + let expr = self.reader.read_const_expr()?; + Ok(ElementItem::Expr(expr)) + } else { + let idx = self.reader.read_var_u32()?; + Ok(ElementItem::Func(idx)) + } + } +} + +impl<'a> IntoIterator for ElementItemsReader<'a> { + type Item = Result>; + type IntoIter = ElementItemsIterator<'a>; + fn into_iter(self) -> Self::IntoIter { + let count = self.count; + ElementItemsIterator { + reader: self, + left: count, + err: false, + } + } +} + +/// An iterator over element items in an element segment. +pub struct ElementItemsIterator<'a> { + reader: ElementItemsReader<'a>, + left: u32, + err: bool, +} + +impl<'a> Iterator for ElementItemsIterator<'a> { + type Item = Result>; + fn next(&mut self) -> Option { + if self.err || self.left == 0 { + return None; + } + let result = self.reader.read(); + self.err = result.is_err(); + self.left -= 1; + Some(result) + } + fn size_hint(&self) -> (usize, Option) { + let count = self.reader.get_count() as usize; + (count, Some(count)) + } +} + +/// A reader for the element section of a WebAssembly module. +#[derive(Clone)] +pub struct ElementSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> ElementSectionReader<'a> { + /// Constructs a new `ElementSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result> { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(ElementSectionReader { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the element section. + /// + /// # Examples + /// + /// ```no_run + /// # let data: &[u8] = &[]; + /// use wasmparser::{ElementSectionReader, ElementKind}; + /// let mut element_reader = ElementSectionReader::new(data, 0).unwrap(); + /// for _ in 0..element_reader.get_count() { + /// let element = element_reader.read().expect("element"); + /// if let ElementKind::Active { offset_expr, .. } = element.kind { + /// let mut offset_expr_reader = offset_expr.get_binary_reader(); + /// let op = offset_expr_reader.read_operator().expect("op"); + /// println!("offset expression: {:?}", op); + /// } + /// let mut items_reader = element.items.get_items_reader().expect("items reader"); + /// for _ in 0..items_reader.get_count() { + /// let item = items_reader.read().expect("item"); + /// println!(" Item: {:?}", item); + /// } + /// } + /// ``` + pub fn read<'b>(&mut self) -> Result> + where + 'a: 'b, + { + let elem_start = self.reader.original_position(); + // The current handling of the flags is largely specified in the `bulk-memory` proposal, + // which at the time this commend is written has been merged to the main specification + // draft. + // + // Notably, this proposal allows multiple different encodings of the table index 0. `00` + // and `02 00` are both valid ways to specify the 0-th table. However it also makes + // another encoding of the 0-th memory `80 00` no longer valid. + // + // We, however maintain this support by parsing `flags` as a LEB128 integer. In that case, + // `80 00` encoding is parsed out as `0` and is therefore assigned a `tableidx` 0, even + // though the current specification draft does not allow for this. + // + // See also https://github.com/WebAssembly/spec/issues/1439 + let flags = self.reader.read_var_u32()?; + if (flags & !0b111) != 0 { + return Err(BinaryReaderError::new( + "invalid flags byte in element segment", + self.reader.original_position() - 1, + )); + } + let kind = if flags & 0b001 != 0 { + if flags & 0b010 != 0 { + ElementKind::Declared + } else { + ElementKind::Passive + } + } else { + let table_index = if flags & 0b010 == 0 { + 0 + } else { + self.reader.read_var_u32()? + }; + let offset_expr = { + let expr_offset = self.reader.position; + self.reader.skip_const_expr()?; + let data = &self.reader.buffer[expr_offset..self.reader.position]; + ConstExpr::new(data, self.reader.original_offset + expr_offset) + }; + ElementKind::Active { + table_index, + offset_expr, + } + }; + let exprs = flags & 0b100 != 0; + let ty = if flags & 0b011 != 0 { + if exprs { + self.reader.read_val_type()? + } else { + match self.reader.read_external_kind()? { + ExternalKind::Func => ValType::FuncRef, + _ => { + return Err(BinaryReaderError::new( + "only the function external type is supported in elem segment", + self.reader.original_position() - 1, + )); + } + } + } + } else { + ValType::FuncRef + }; + let data_start = self.reader.position; + let items_count = self.reader.read_var_u32()?; + if exprs { + for _ in 0..items_count { + self.reader.skip_const_expr()?; + } + } else { + for _ in 0..items_count { + self.reader.read_var_u32()?; + } + } + let data_end = self.reader.position; + let items = ElementItems { + offset: self.reader.original_offset + data_start, + data: &self.reader.buffer[data_start..data_end], + exprs, + }; + + let elem_end = self.reader.original_position(); + let range = elem_start..elem_end; + + Ok(Element { + kind, + items, + ty, + range, + }) + } +} + +impl<'a> SectionReader for ElementSectionReader<'a> { + type Item = Element<'a>; + fn read(&mut self) -> Result { + ElementSectionReader::read(self) + } + fn eof(&self) -> bool { + self.reader.eof() + } + fn original_position(&self) -> usize { + ElementSectionReader::original_position(self) + } + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for ElementSectionReader<'a> { + fn get_count(&self) -> u32 { + ElementSectionReader::get_count(self) + } +} + +impl<'a> IntoIterator for ElementSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIteratorLimited>; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/core/exports.rs b/crates/wasmparser/src/readers/core/exports.rs new file mode 100644 index 000000000..0f4eb0a3a --- /dev/null +++ b/crates/wasmparser/src/readers/core/exports.rs @@ -0,0 +1,123 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{BinaryReader, Result, SectionIteratorLimited, SectionReader, SectionWithLimitedItems}; +use std::ops::Range; + +/// External types as defined [here]. +/// +/// [here]: https://webassembly.github.io/spec/core/syntax/types.html#external-types +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum ExternalKind { + /// The external kind is a function. + Func, + /// The external kind if a table. + Table, + /// The external kind is a memory. + Memory, + /// The external kind is a global. + Global, + /// The external kind is a tag. + Tag, +} + +/// Represents an export in a WebAssembly module. +#[derive(Debug, Copy, Clone)] +pub struct Export<'a> { + /// The name of the exported item. + pub name: &'a str, + /// The kind of the export. + pub kind: ExternalKind, + /// The index of the exported item. + pub index: u32, +} + +/// A reader for the export section of a WebAssembly module. +#[derive(Clone)] +pub struct ExportSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> ExportSectionReader<'a> { + /// Constructs a new `ExportSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(Self { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the export section. + /// + /// # Examples + /// ``` + /// use wasmparser::ExportSectionReader; + /// + /// # let data: &[u8] = &[0x01, 0x01, 0x65, 0x00, 0x00]; + /// let mut reader = ExportSectionReader::new(data, 0).unwrap(); + /// for _ in 0..reader.get_count() { + /// let export = reader.read().expect("export"); + /// println!("Export: {:?}", export); + /// } + /// ``` + pub fn read(&mut self) -> Result> { + self.reader.read_export() + } +} + +impl<'a> SectionReader for ExportSectionReader<'a> { + type Item = Export<'a>; + + fn read(&mut self) -> Result { + Self::read(self) + } + + fn eof(&self) -> bool { + self.reader.eof() + } + + fn original_position(&self) -> usize { + Self::original_position(self) + } + + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for ExportSectionReader<'a> { + fn get_count(&self) -> u32 { + Self::get_count(self) + } +} + +impl<'a> IntoIterator for ExportSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIteratorLimited; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/core/functions.rs b/crates/wasmparser/src/readers/core/functions.rs new file mode 100644 index 000000000..a98b7fa9f --- /dev/null +++ b/crates/wasmparser/src/readers/core/functions.rs @@ -0,0 +1,95 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{BinaryReader, Result, SectionIteratorLimited, SectionReader, SectionWithLimitedItems}; +use std::ops::Range; + +/// A reader for the function section of a WebAssembly module. +#[derive(Clone)] +pub struct FunctionSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> FunctionSectionReader<'a> { + /// Constructs a new `FunctionSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(Self { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads function type index from the function section. + /// + /// # Examples + /// + /// ``` + /// use wasmparser::FunctionSectionReader; + /// # let data: &[u8] = &[0x01, 0x00]; + /// let mut reader = FunctionSectionReader::new(data, 0).unwrap(); + /// for _ in 0..reader.get_count() { + /// let ty = reader.read().expect("function type index"); + /// println!("Function type index: {}", ty); + /// } + /// ``` + pub fn read(&mut self) -> Result { + self.reader.read_var_u32() + } +} + +impl<'a> SectionReader for FunctionSectionReader<'a> { + type Item = u32; + + fn read(&mut self) -> Result { + Self::read(self) + } + + fn eof(&self) -> bool { + self.reader.eof() + } + + fn original_position(&self) -> usize { + Self::original_position(self) + } + + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for FunctionSectionReader<'a> { + fn get_count(&self) -> u32 { + Self::get_count(self) + } +} + +impl<'a> IntoIterator for FunctionSectionReader<'a> { + type Item = Result; + type IntoIter = SectionIteratorLimited; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/core/globals.rs b/crates/wasmparser/src/readers/core/globals.rs new file mode 100644 index 000000000..49e31c320 --- /dev/null +++ b/crates/wasmparser/src/readers/core/globals.rs @@ -0,0 +1,110 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{ + BinaryReader, ConstExpr, GlobalType, Result, SectionIteratorLimited, SectionReader, + SectionWithLimitedItems, +}; +use std::ops::Range; + +/// Represents a core WebAssembly global. +#[derive(Debug, Copy, Clone)] +pub struct Global<'a> { + /// The global's type. + pub ty: GlobalType, + /// The global's initialization expression. + pub init_expr: ConstExpr<'a>, +} + +/// A reader for the global section of a WebAssembly module. +#[derive(Clone)] +pub struct GlobalSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> GlobalSectionReader<'a> { + /// Constructs a new `GlobalSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result> { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(GlobalSectionReader { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the global section. + /// + /// # Examples + /// ``` + /// use wasmparser::GlobalSectionReader; + /// # let data: &[u8] = &[0x01, 0x7F, 0x01, 0x41, 0x90, 0x88, 0x04, 0x0B]; + /// let mut global_reader = GlobalSectionReader::new(data, 0).unwrap(); + /// for _ in 0..global_reader.get_count() { + /// let global = global_reader.read().expect("global"); + /// println!("Global: {:?}", global); + /// let mut init_expr_reader = global.init_expr.get_binary_reader(); + /// let op = init_expr_reader.read_operator().expect("op"); + /// println!("Init const: {:?}", op); + /// } + /// ``` + pub fn read<'b>(&mut self) -> Result> + where + 'a: 'b, + { + let ty = self.reader.read_global_type()?; + let init_expr = self.reader.read_const_expr()?; + Ok(Global { ty, init_expr }) + } +} + +impl<'a> SectionReader for GlobalSectionReader<'a> { + type Item = Global<'a>; + fn read(&mut self) -> Result { + GlobalSectionReader::read(self) + } + fn eof(&self) -> bool { + self.reader.eof() + } + fn original_position(&self) -> usize { + GlobalSectionReader::original_position(self) + } + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for GlobalSectionReader<'a> { + fn get_count(&self) -> u32 { + GlobalSectionReader::get_count(self) + } +} + +impl<'a> IntoIterator for GlobalSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIteratorLimited>; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/core/imports.rs b/crates/wasmparser/src/readers/core/imports.rs new file mode 100644 index 000000000..a8a7a5d5a --- /dev/null +++ b/crates/wasmparser/src/readers/core/imports.rs @@ -0,0 +1,129 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{ + BinaryReader, GlobalType, MemoryType, Result, SectionIteratorLimited, SectionReader, + SectionWithLimitedItems, TableType, TagType, +}; +use std::ops::Range; + +/// Represents a reference to a type definition in a WebAssembly module. +#[derive(Debug, Clone, Copy)] +pub enum TypeRef { + /// The type is a function. + /// + /// The value is an index into the type section. + Func(u32), + /// The type is a table. + Table(TableType), + /// The type is a memory. + Memory(MemoryType), + /// The type is a global. + Global(GlobalType), + /// The type is a tag. + /// + /// This variant is only used for the exception handling proposal. + /// + /// The value is an index in the types index space. + Tag(TagType), +} + +/// Represents an import in a WebAssembly module. +#[derive(Debug, Copy, Clone)] +pub struct Import<'a> { + /// The module being imported from. + pub module: &'a str, + /// The name of the imported item. + pub name: &'a str, + /// The type of the imported item. + pub ty: TypeRef, +} + +/// A reader for the import section of a WebAssembly module. +#[derive(Clone)] +pub struct ImportSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> ImportSectionReader<'a> { + /// Constructs a new `ImportSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(Self { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the import section. + /// + /// # Examples + /// ``` + /// use wasmparser::ImportSectionReader; + /// let data: &[u8] = &[0x01, 0x01, 0x41, 0x01, 0x66, 0x00, 0x00]; + /// let mut reader = ImportSectionReader::new(data, 0).unwrap(); + /// for _ in 0..reader.get_count() { + /// let import = reader.read().expect("import"); + /// println!("Import: {:?}", import); + /// } + /// ``` + pub fn read(&mut self) -> Result> { + self.reader.read_import() + } +} + +impl<'a> SectionReader for ImportSectionReader<'a> { + type Item = Import<'a>; + + fn read(&mut self) -> Result { + Self::read(self) + } + + fn eof(&self) -> bool { + self.reader.eof() + } + + fn original_position(&self) -> usize { + Self::original_position(self) + } + + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for ImportSectionReader<'a> { + fn get_count(&self) -> u32 { + Self::get_count(self) + } +} + +impl<'a> IntoIterator for ImportSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIteratorLimited; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/core/init.rs b/crates/wasmparser/src/readers/core/init.rs new file mode 100644 index 000000000..ad7e677ad --- /dev/null +++ b/crates/wasmparser/src/readers/core/init.rs @@ -0,0 +1,46 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{BinaryReader, OperatorsReader}; + +/// Represents an initialization expression. +#[derive(Debug, Copy, Clone)] +pub struct ConstExpr<'a> { + offset: usize, + data: &'a [u8], +} + +impl<'a> ConstExpr<'a> { + /// Constructs a new `ConstExpr` from the given data and offset. + pub fn new(data: &[u8], offset: usize) -> ConstExpr { + ConstExpr { offset, data } + } + + /// Gets a binary reader for the initialization expression. + pub fn get_binary_reader<'b>(&self) -> BinaryReader<'b> + where + 'a: 'b, + { + BinaryReader::new_with_offset(self.data, self.offset) + } + + /// Gets an operators reader for the initialization expression. + pub fn get_operators_reader<'b>(&self) -> OperatorsReader<'b> + where + 'a: 'b, + { + OperatorsReader::new(self.data, self.offset) + } +} diff --git a/crates/wasmparser/src/readers/core/linking.rs b/crates/wasmparser/src/readers/core/linking.rs new file mode 100644 index 000000000..a619288dd --- /dev/null +++ b/crates/wasmparser/src/readers/core/linking.rs @@ -0,0 +1,88 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{BinaryReader, Result, SectionIteratorLimited, SectionReader, SectionWithLimitedItems}; +use std::ops::Range; + +/// Represents a linking type. +#[derive(Debug, Copy, Clone)] +pub enum LinkingType { + /// The linking uses a stack pointer. + StackPointer(u32), +} + +/// A reader for the linking custom section of a WebAssembly module. +pub struct LinkingSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> LinkingSectionReader<'a> { + /// Constructs a new `LinkingSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result> { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(LinkingSectionReader { reader, count }) + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Gets the original position of the reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Reads an item from the section. + pub fn read<'b>(&mut self) -> Result + where + 'a: 'b, + { + self.reader.read_linking_type() + } +} + +impl<'a> SectionReader for LinkingSectionReader<'a> { + type Item = LinkingType; + fn read(&mut self) -> Result { + LinkingSectionReader::read(self) + } + fn eof(&self) -> bool { + self.reader.eof() + } + fn original_position(&self) -> usize { + LinkingSectionReader::original_position(self) + } + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for LinkingSectionReader<'a> { + fn get_count(&self) -> u32 { + LinkingSectionReader::get_count(self) + } +} + +impl<'a> IntoIterator for LinkingSectionReader<'a> { + type Item = Result; + type IntoIter = SectionIteratorLimited>; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/core/memories.rs b/crates/wasmparser/src/readers/core/memories.rs new file mode 100644 index 000000000..23d1cdcac --- /dev/null +++ b/crates/wasmparser/src/readers/core/memories.rs @@ -0,0 +1,93 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{ + BinaryReader, MemoryType, Result, SectionIteratorLimited, SectionReader, + SectionWithLimitedItems, +}; +use std::ops::Range; + +/// A reader for the memory section of a WebAssembly module. +#[derive(Clone)] +pub struct MemorySectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> MemorySectionReader<'a> { + /// Constructs a new `MemorySectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result> { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(MemorySectionReader { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the memory section. + /// + /// # Examples + /// ``` + /// use wasmparser::MemorySectionReader; + /// # let data: &[u8] = &[0x01, 0x00, 0x02]; + /// let mut memory_reader = MemorySectionReader::new(data, 0).unwrap(); + /// for _ in 0..memory_reader.get_count() { + /// let memory = memory_reader.read().expect("memory"); + /// println!("Memory: {:?}", memory); + /// } + /// ``` + pub fn read(&mut self) -> Result { + self.reader.read_memory_type() + } +} + +impl<'a> SectionReader for MemorySectionReader<'a> { + type Item = MemoryType; + fn read(&mut self) -> Result { + MemorySectionReader::read(self) + } + fn eof(&self) -> bool { + self.reader.eof() + } + fn original_position(&self) -> usize { + MemorySectionReader::original_position(self) + } + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for MemorySectionReader<'a> { + fn get_count(&self) -> u32 { + MemorySectionReader::get_count(self) + } +} + +impl<'a> IntoIterator for MemorySectionReader<'a> { + type Item = Result; + type IntoIter = SectionIteratorLimited>; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/core/names.rs b/crates/wasmparser/src/readers/core/names.rs new file mode 100644 index 000000000..6b8f48064 --- /dev/null +++ b/crates/wasmparser/src/readers/core/names.rs @@ -0,0 +1,355 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{BinaryReader, BinaryReaderError, Result, SectionIterator, SectionReader}; +use std::ops::Range; + +/// Represents a name for an index from the names section. +#[derive(Debug, Copy, Clone)] +pub struct Naming<'a> { + /// The index being named. + pub index: u32, + /// The name for the index. + pub name: &'a str, +} + +/// Represents the type of name. +#[derive(Debug, Copy, Clone)] +pub enum NameType { + /// The name is for a module. + Module, + /// The name is for a function. + Function, + /// The name is for a local. + Local, + /// The name is for a label. + Label, + /// The name is for a type. + Type, + /// The name is for a table. + Table, + /// The name is for a memory. + Memory, + /// The name is for a global. + Global, + /// The name is for an element segment. + Element, + /// The name is for a data segment. + Data, + /// The name is unknown. + /// + /// The value is the unknown section identifier. + Unknown(u8), +} + +/// Represents a single name in the names custom section. +#[derive(Debug, Copy, Clone)] +pub struct SingleName<'a> { + data: &'a [u8], + offset: usize, +} + +impl<'a> SingleName<'a> { + /// Gets the name as a string. + pub fn get_name<'b>(&self) -> Result<&'b str> + where + 'a: 'b, + { + let mut reader = BinaryReader::new_with_offset(self.data, self.offset); + reader.read_string() + } + + /// Gets the original position of the name. + pub fn original_position(&self) -> usize { + self.offset + } +} + +/// A reader for direct names in the names custom section. +pub struct NamingReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> NamingReader<'a> { + fn new(data: &'a [u8], offset: usize) -> Result> { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(NamingReader { reader, count }) + } + + fn skip(reader: &mut BinaryReader) -> Result<()> { + let count = reader.read_var_u32()?; + for _ in 0..count { + reader.read_var_u32()?; + reader.skip_string()?; + } + Ok(()) + } + + /// Gets the original position of the reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads a name from the names custom section. + pub fn read<'b>(&mut self) -> Result> + where + 'a: 'b, + { + let index = self.reader.read_var_u32()?; + let name = self.reader.read_string()?; + Ok(Naming { index, name }) + } +} + +/// Represents a name map from the names custom section. +#[derive(Debug, Copy, Clone)] +pub struct NameMap<'a> { + data: &'a [u8], + offset: usize, +} + +impl<'a> NameMap<'a> { + /// Gets a naming reader for the map. + pub fn get_map<'b>(&self) -> Result> + where + 'a: 'b, + { + NamingReader::new(self.data, self.offset) + } + + /// Gets the original position of the map. + pub fn original_position(&self) -> usize { + self.offset + } +} + +/// Represents an indirect name in the names custom section. +#[derive(Debug, Copy, Clone)] +pub struct IndirectNaming<'a> { + /// The indirect index of the name. + pub indirect_index: u32, + data: &'a [u8], + offset: usize, +} + +impl<'a> IndirectNaming<'a> { + /// Gets the naming reader for the indirect name. + pub fn get_map<'b>(&self) -> Result> + where + 'a: 'b, + { + NamingReader::new(self.data, self.offset) + } + + /// Gets the original position of the indirect name. + pub fn original_position(&self) -> usize { + self.offset + } +} + +/// Represents a reader for indirect names from the names custom section. +pub struct IndirectNamingReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> IndirectNamingReader<'a> { + fn new(data: &'a [u8], offset: usize) -> Result> { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(IndirectNamingReader { reader, count }) + } + + /// Gets the count of indirect names. + pub fn get_indirect_count(&self) -> u32 { + self.count + } + + /// Gets the original position of the reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Reads an indirect name from the reader. + pub fn read<'b>(&mut self) -> Result> + where + 'a: 'b, + { + let index = self.reader.read_var_u32()?; + let start = self.reader.position; + NamingReader::skip(&mut self.reader)?; + let end = self.reader.position; + Ok(IndirectNaming { + indirect_index: index, + data: &self.reader.buffer[start..end], + offset: self.reader.original_offset + start, + }) + } +} + +/// Represents an indirect name map. +#[derive(Debug, Copy, Clone)] +pub struct IndirectNameMap<'a> { + data: &'a [u8], + offset: usize, +} + +impl<'a> IndirectNameMap<'a> { + /// Gets an indirect naming reader for the map. + pub fn get_indirect_map<'b>(&self) -> Result> + where + 'a: 'b, + { + IndirectNamingReader::new(self.data, self.offset) + } + + /// Gets an original position of the map. + pub fn original_position(&self) -> usize { + self.offset + } +} + +/// Represents a name read from the names custom section. +#[derive(Debug, Clone)] +pub enum Name<'a> { + /// The name is for the module. + Module(SingleName<'a>), + /// The name is for the functions. + Function(NameMap<'a>), + /// The name is for the function locals. + Local(IndirectNameMap<'a>), + /// The name is for the function labels. + Label(IndirectNameMap<'a>), + /// The name is for the types. + Type(NameMap<'a>), + /// The name is for the tables. + Table(NameMap<'a>), + /// The name is for the memories. + Memory(NameMap<'a>), + /// The name is for the globals. + Global(NameMap<'a>), + /// The name is for the element segments. + Element(NameMap<'a>), + /// The name is for the data segments. + Data(NameMap<'a>), + /// An unknown [name subsection](https://webassembly.github.io/spec/core/appendix/custom.html#subsections). + Unknown { + /// The identifier for this subsection. + ty: u8, + /// The contents of this subsection. + data: &'a [u8], + /// The range of bytes, relative to the start of the original data + /// stream, that the contents of this subsection reside in. + range: Range, + }, +} + +/// A reader for the name custom section of a WebAssembly module. +pub struct NameSectionReader<'a> { + reader: BinaryReader<'a>, +} + +impl<'a> NameSectionReader<'a> { + /// Constructs a new `NameSectionReader` from the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result> { + Ok(NameSectionReader { + reader: BinaryReader::new_with_offset(data, offset), + }) + } + + fn verify_section_end(&self, end: usize) -> Result<()> { + if self.reader.buffer.len() < end { + return Err(BinaryReaderError::new( + "name entry extends past end of the code section", + self.reader.original_offset + self.reader.buffer.len(), + )); + } + Ok(()) + } + + /// Determines if the reader is at the end of the section. + pub fn eof(&self) -> bool { + self.reader.eof() + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Reads a name from the section. + pub fn read<'b>(&mut self) -> Result> + where + 'a: 'b, + { + let ty = self.reader.read_name_type()?; + let payload_len = self.reader.read_var_u32()? as usize; + let payload_start = self.reader.position; + let payload_end = payload_start + payload_len; + self.verify_section_end(payload_end)?; + let offset = self.reader.original_offset + payload_start; + let data = &self.reader.buffer[payload_start..payload_end]; + self.reader.skip_to(payload_end); + Ok(match ty { + NameType::Module => Name::Module(SingleName { data, offset }), + NameType::Function => Name::Function(NameMap { data, offset }), + NameType::Local => Name::Local(IndirectNameMap { data, offset }), + NameType::Label => Name::Label(IndirectNameMap { data, offset }), + NameType::Type => Name::Type(NameMap { data, offset }), + NameType::Table => Name::Table(NameMap { data, offset }), + NameType::Memory => Name::Memory(NameMap { data, offset }), + NameType::Global => Name::Global(NameMap { data, offset }), + NameType::Element => Name::Element(NameMap { data, offset }), + NameType::Data => Name::Data(NameMap { data, offset }), + NameType::Unknown(ty) => Name::Unknown { + ty, + data, + range: offset..offset + payload_len, + }, + }) + } +} + +impl<'a> SectionReader for NameSectionReader<'a> { + type Item = Name<'a>; + fn read(&mut self) -> Result { + NameSectionReader::read(self) + } + fn eof(&self) -> bool { + NameSectionReader::eof(self) + } + fn original_position(&self) -> usize { + NameSectionReader::original_position(self) + } + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> IntoIterator for NameSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIterator>; + + fn into_iter(self) -> Self::IntoIter { + SectionIterator::new(self) + } +} diff --git a/crates/wasmparser/src/readers/core/operators.rs b/crates/wasmparser/src/readers/core/operators.rs new file mode 100644 index 000000000..689d0950f --- /dev/null +++ b/crates/wasmparser/src/readers/core/operators.rs @@ -0,0 +1,2496 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{BinaryReader, BinaryReaderError, Result, ValType}; + +/// Represents a block type. +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum BlockType { + /// The block produces consumes nor produces any values. + Empty, + /// The block produces a singular value of the given type ([] -> \[t]). + Type(ValType), + /// The block is described by a function type. + /// + /// The index is to a function type in the types section. + FuncType(u32), +} + +/// Represents a memory immediate in a WebAssembly memory instruction. +#[derive(Debug, Copy, Clone)] +pub struct MemoryImmediate { + /// Alignment, stored as `n` where the actual alignment is `2^n` + pub align: u8, + /// A fixed byte-offset that this memory immediate specifies. + /// + /// Note that the memory64 proposal can specify a full 64-bit byte offset + /// while otherwise only 32-bit offsets are allowed. Once validated + /// memory immediates for 32-bit memories are guaranteed to be at most + /// `u32::MAX` whereas 64-bit memories can use the full 64-bits. + pub offset: u64, + /// The index of the memory this immediate points to. + /// + /// Note that this points within the module's own memory index space, and + /// is always zero unless the multi-memory proposal of WebAssembly is + /// enabled. + pub memory: u32, +} + +/// A br_table entries representation. +#[derive(Clone)] +pub struct BrTable<'a> { + pub(crate) reader: crate::BinaryReader<'a>, + pub(crate) cnt: u32, + pub(crate) default: u32, +} + +/// An IEEE binary32 immediate floating point value, represented as a u32 +/// containing the bit pattern. +/// +/// All bit patterns are allowed. +#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)] +pub struct Ieee32(pub(crate) u32); + +impl Ieee32 { + /// Gets the underlying bits of the 32-bit float. + pub fn bits(self) -> u32 { + self.0 + } +} + +/// An IEEE binary64 immediate floating point value, represented as a u64 +/// containing the bit pattern. +/// +/// All bit patterns are allowed. +#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)] +pub struct Ieee64(pub(crate) u64); + +impl Ieee64 { + /// Gets the underlying bits of the 64-bit float. + pub fn bits(self) -> u64 { + self.0 + } +} + +/// Represents a 128-bit vector value. +#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)] +pub struct V128(pub(crate) [u8; 16]); + +impl V128 { + /// Gets the bytes of the vector value. + pub fn bytes(&self) -> &[u8; 16] { + &self.0 + } + + /// Gets a signed 128-bit integer value from the vector's bytes. + pub fn i128(&self) -> i128 { + i128::from_le_bytes(self.0) + } +} + +/// Represents a SIMD lane index. +pub type SIMDLaneIndex = u8; + +/// Instructions as defined [here]. +/// +/// [here]: https://webassembly.github.io/spec/core/binary/instructions.html +#[derive(Debug, Clone)] +#[allow(missing_docs)] +pub enum Operator<'a> { + Unreachable, + Nop, + Block { + ty: BlockType, + }, + Loop { + ty: BlockType, + }, + If { + ty: BlockType, + }, + Else, + Try { + ty: BlockType, + }, + Catch { + index: u32, + }, + Throw { + index: u32, + }, + Rethrow { + relative_depth: u32, + }, + End, + Br { + relative_depth: u32, + }, + BrIf { + relative_depth: u32, + }, + BrTable { + table: BrTable<'a>, + }, + Return, + Call { + function_index: u32, + }, + CallIndirect { + index: u32, + table_index: u32, + table_byte: u8, + }, + ReturnCall { + function_index: u32, + }, + ReturnCallIndirect { + index: u32, + table_index: u32, + }, + Delegate { + relative_depth: u32, + }, + CatchAll, + Drop, + Select, + TypedSelect { + ty: ValType, + }, + LocalGet { + local_index: u32, + }, + LocalSet { + local_index: u32, + }, + LocalTee { + local_index: u32, + }, + GlobalGet { + global_index: u32, + }, + GlobalSet { + global_index: u32, + }, + I32Load { + memarg: MemoryImmediate, + }, + I64Load { + memarg: MemoryImmediate, + }, + F32Load { + memarg: MemoryImmediate, + }, + F64Load { + memarg: MemoryImmediate, + }, + I32Load8S { + memarg: MemoryImmediate, + }, + I32Load8U { + memarg: MemoryImmediate, + }, + I32Load16S { + memarg: MemoryImmediate, + }, + I32Load16U { + memarg: MemoryImmediate, + }, + I64Load8S { + memarg: MemoryImmediate, + }, + I64Load8U { + memarg: MemoryImmediate, + }, + I64Load16S { + memarg: MemoryImmediate, + }, + I64Load16U { + memarg: MemoryImmediate, + }, + I64Load32S { + memarg: MemoryImmediate, + }, + I64Load32U { + memarg: MemoryImmediate, + }, + I32Store { + memarg: MemoryImmediate, + }, + I64Store { + memarg: MemoryImmediate, + }, + F32Store { + memarg: MemoryImmediate, + }, + F64Store { + memarg: MemoryImmediate, + }, + I32Store8 { + memarg: MemoryImmediate, + }, + I32Store16 { + memarg: MemoryImmediate, + }, + I64Store8 { + memarg: MemoryImmediate, + }, + I64Store16 { + memarg: MemoryImmediate, + }, + I64Store32 { + memarg: MemoryImmediate, + }, + MemorySize { + mem: u32, + mem_byte: u8, + }, + MemoryGrow { + mem: u32, + mem_byte: u8, + }, + I32Const { + value: i32, + }, + I64Const { + value: i64, + }, + F32Const { + value: Ieee32, + }, + F64Const { + value: Ieee64, + }, + RefNull { + ty: ValType, + }, + RefIsNull, + RefFunc { + function_index: u32, + }, + I32Eqz, + I32Eq, + I32Ne, + I32LtS, + I32LtU, + I32GtS, + I32GtU, + I32LeS, + I32LeU, + I32GeS, + I32GeU, + I64Eqz, + I64Eq, + I64Ne, + I64LtS, + I64LtU, + I64GtS, + I64GtU, + I64LeS, + I64LeU, + I64GeS, + I64GeU, + F32Eq, + F32Ne, + F32Lt, + F32Gt, + F32Le, + F32Ge, + F64Eq, + F64Ne, + F64Lt, + F64Gt, + F64Le, + F64Ge, + I32Clz, + I32Ctz, + I32Popcnt, + I32Add, + I32Sub, + I32Mul, + I32DivS, + I32DivU, + I32RemS, + I32RemU, + I32And, + I32Or, + I32Xor, + I32Shl, + I32ShrS, + I32ShrU, + I32Rotl, + I32Rotr, + I64Clz, + I64Ctz, + I64Popcnt, + I64Add, + I64Sub, + I64Mul, + I64DivS, + I64DivU, + I64RemS, + I64RemU, + I64And, + I64Or, + I64Xor, + I64Shl, + I64ShrS, + I64ShrU, + I64Rotl, + I64Rotr, + F32Abs, + F32Neg, + F32Ceil, + F32Floor, + F32Trunc, + F32Nearest, + F32Sqrt, + F32Add, + F32Sub, + F32Mul, + F32Div, + F32Min, + F32Max, + F32Copysign, + F64Abs, + F64Neg, + F64Ceil, + F64Floor, + F64Trunc, + F64Nearest, + F64Sqrt, + F64Add, + F64Sub, + F64Mul, + F64Div, + F64Min, + F64Max, + F64Copysign, + I32WrapI64, + I32TruncF32S, + I32TruncF32U, + I32TruncF64S, + I32TruncF64U, + I64ExtendI32S, + I64ExtendI32U, + I64TruncF32S, + I64TruncF32U, + I64TruncF64S, + I64TruncF64U, + F32ConvertI32S, + F32ConvertI32U, + F32ConvertI64S, + F32ConvertI64U, + F32DemoteF64, + F64ConvertI32S, + F64ConvertI32U, + F64ConvertI64S, + F64ConvertI64U, + F64PromoteF32, + I32ReinterpretF32, + I64ReinterpretF64, + F32ReinterpretI32, + F64ReinterpretI64, + I32Extend8S, + I32Extend16S, + I64Extend8S, + I64Extend16S, + I64Extend32S, + + // 0xF1 operators + // memory protection key + Rdpkru, + Wrpkru, + + // 0xFC operators + // Non-trapping Float-to-int Conversions + I32TruncSatF32S, + I32TruncSatF32U, + I32TruncSatF64S, + I32TruncSatF64U, + I64TruncSatF32S, + I64TruncSatF32U, + I64TruncSatF64S, + I64TruncSatF64U, + + // 0xFC operators + // bulk memory https://github.com/WebAssembly/bulk-memory-operations/blob/master/proposals/bulk-memory-operations/Overview.md + MemoryInit { + segment: u32, + mem: u32, + }, + DataDrop { + segment: u32, + }, + MemoryCopy { + src: u32, + dst: u32, + }, + MemoryFill { + mem: u32, + }, + TableInit { + segment: u32, + table: u32, + }, + ElemDrop { + segment: u32, + }, + TableCopy { + dst_table: u32, + src_table: u32, + }, + TableFill { + table: u32, + }, + TableGet { + table: u32, + }, + TableSet { + table: u32, + }, + TableGrow { + table: u32, + }, + TableSize { + table: u32, + }, + + // 0xFE operators + // https://github.com/WebAssembly/threads/blob/master/proposals/threads/Overview.md + MemoryAtomicNotify { + memarg: MemoryImmediate, + }, + MemoryAtomicWait32 { + memarg: MemoryImmediate, + }, + MemoryAtomicWait64 { + memarg: MemoryImmediate, + }, + AtomicFence { + flags: u8, + }, + I32AtomicLoad { + memarg: MemoryImmediate, + }, + I64AtomicLoad { + memarg: MemoryImmediate, + }, + I32AtomicLoad8U { + memarg: MemoryImmediate, + }, + I32AtomicLoad16U { + memarg: MemoryImmediate, + }, + I64AtomicLoad8U { + memarg: MemoryImmediate, + }, + I64AtomicLoad16U { + memarg: MemoryImmediate, + }, + I64AtomicLoad32U { + memarg: MemoryImmediate, + }, + I32AtomicStore { + memarg: MemoryImmediate, + }, + I64AtomicStore { + memarg: MemoryImmediate, + }, + I32AtomicStore8 { + memarg: MemoryImmediate, + }, + I32AtomicStore16 { + memarg: MemoryImmediate, + }, + I64AtomicStore8 { + memarg: MemoryImmediate, + }, + I64AtomicStore16 { + memarg: MemoryImmediate, + }, + I64AtomicStore32 { + memarg: MemoryImmediate, + }, + I32AtomicRmwAdd { + memarg: MemoryImmediate, + }, + I64AtomicRmwAdd { + memarg: MemoryImmediate, + }, + I32AtomicRmw8AddU { + memarg: MemoryImmediate, + }, + I32AtomicRmw16AddU { + memarg: MemoryImmediate, + }, + I64AtomicRmw8AddU { + memarg: MemoryImmediate, + }, + I64AtomicRmw16AddU { + memarg: MemoryImmediate, + }, + I64AtomicRmw32AddU { + memarg: MemoryImmediate, + }, + I32AtomicRmwSub { + memarg: MemoryImmediate, + }, + I64AtomicRmwSub { + memarg: MemoryImmediate, + }, + I32AtomicRmw8SubU { + memarg: MemoryImmediate, + }, + I32AtomicRmw16SubU { + memarg: MemoryImmediate, + }, + I64AtomicRmw8SubU { + memarg: MemoryImmediate, + }, + I64AtomicRmw16SubU { + memarg: MemoryImmediate, + }, + I64AtomicRmw32SubU { + memarg: MemoryImmediate, + }, + I32AtomicRmwAnd { + memarg: MemoryImmediate, + }, + I64AtomicRmwAnd { + memarg: MemoryImmediate, + }, + I32AtomicRmw8AndU { + memarg: MemoryImmediate, + }, + I32AtomicRmw16AndU { + memarg: MemoryImmediate, + }, + I64AtomicRmw8AndU { + memarg: MemoryImmediate, + }, + I64AtomicRmw16AndU { + memarg: MemoryImmediate, + }, + I64AtomicRmw32AndU { + memarg: MemoryImmediate, + }, + I32AtomicRmwOr { + memarg: MemoryImmediate, + }, + I64AtomicRmwOr { + memarg: MemoryImmediate, + }, + I32AtomicRmw8OrU { + memarg: MemoryImmediate, + }, + I32AtomicRmw16OrU { + memarg: MemoryImmediate, + }, + I64AtomicRmw8OrU { + memarg: MemoryImmediate, + }, + I64AtomicRmw16OrU { + memarg: MemoryImmediate, + }, + I64AtomicRmw32OrU { + memarg: MemoryImmediate, + }, + I32AtomicRmwXor { + memarg: MemoryImmediate, + }, + I64AtomicRmwXor { + memarg: MemoryImmediate, + }, + I32AtomicRmw8XorU { + memarg: MemoryImmediate, + }, + I32AtomicRmw16XorU { + memarg: MemoryImmediate, + }, + I64AtomicRmw8XorU { + memarg: MemoryImmediate, + }, + I64AtomicRmw16XorU { + memarg: MemoryImmediate, + }, + I64AtomicRmw32XorU { + memarg: MemoryImmediate, + }, + I32AtomicRmwXchg { + memarg: MemoryImmediate, + }, + I64AtomicRmwXchg { + memarg: MemoryImmediate, + }, + I32AtomicRmw8XchgU { + memarg: MemoryImmediate, + }, + I32AtomicRmw16XchgU { + memarg: MemoryImmediate, + }, + I64AtomicRmw8XchgU { + memarg: MemoryImmediate, + }, + I64AtomicRmw16XchgU { + memarg: MemoryImmediate, + }, + I64AtomicRmw32XchgU { + memarg: MemoryImmediate, + }, + I32AtomicRmwCmpxchg { + memarg: MemoryImmediate, + }, + I64AtomicRmwCmpxchg { + memarg: MemoryImmediate, + }, + I32AtomicRmw8CmpxchgU { + memarg: MemoryImmediate, + }, + I32AtomicRmw16CmpxchgU { + memarg: MemoryImmediate, + }, + I64AtomicRmw8CmpxchgU { + memarg: MemoryImmediate, + }, + I64AtomicRmw16CmpxchgU { + memarg: MemoryImmediate, + }, + I64AtomicRmw32CmpxchgU { + memarg: MemoryImmediate, + }, + + // 0xFD operators + // SIMD https://webassembly.github.io/simd/core/binary/instructions.html + V128Load { + memarg: MemoryImmediate, + }, + V128Load8x8S { + memarg: MemoryImmediate, + }, + V128Load8x8U { + memarg: MemoryImmediate, + }, + V128Load16x4S { + memarg: MemoryImmediate, + }, + V128Load16x4U { + memarg: MemoryImmediate, + }, + V128Load32x2S { + memarg: MemoryImmediate, + }, + V128Load32x2U { + memarg: MemoryImmediate, + }, + V128Load8Splat { + memarg: MemoryImmediate, + }, + V128Load16Splat { + memarg: MemoryImmediate, + }, + V128Load32Splat { + memarg: MemoryImmediate, + }, + V128Load64Splat { + memarg: MemoryImmediate, + }, + V128Load32Zero { + memarg: MemoryImmediate, + }, + V128Load64Zero { + memarg: MemoryImmediate, + }, + V128Store { + memarg: MemoryImmediate, + }, + V128Load8Lane { + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + }, + V128Load16Lane { + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + }, + V128Load32Lane { + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + }, + V128Load64Lane { + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + }, + V128Store8Lane { + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + }, + V128Store16Lane { + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + }, + V128Store32Lane { + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + }, + V128Store64Lane { + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + }, + V128Const { + value: V128, + }, + I8x16Shuffle { + lanes: [SIMDLaneIndex; 16], + }, + I8x16ExtractLaneS { + lane: SIMDLaneIndex, + }, + I8x16ExtractLaneU { + lane: SIMDLaneIndex, + }, + I8x16ReplaceLane { + lane: SIMDLaneIndex, + }, + I16x8ExtractLaneS { + lane: SIMDLaneIndex, + }, + I16x8ExtractLaneU { + lane: SIMDLaneIndex, + }, + I16x8ReplaceLane { + lane: SIMDLaneIndex, + }, + I32x4ExtractLane { + lane: SIMDLaneIndex, + }, + I32x4ReplaceLane { + lane: SIMDLaneIndex, + }, + I64x2ExtractLane { + lane: SIMDLaneIndex, + }, + I64x2ReplaceLane { + lane: SIMDLaneIndex, + }, + F32x4ExtractLane { + lane: SIMDLaneIndex, + }, + F32x4ReplaceLane { + lane: SIMDLaneIndex, + }, + F64x2ExtractLane { + lane: SIMDLaneIndex, + }, + F64x2ReplaceLane { + lane: SIMDLaneIndex, + }, + I8x16Swizzle, + I8x16Splat, + I16x8Splat, + I32x4Splat, + I64x2Splat, + F32x4Splat, + F64x2Splat, + I8x16Eq, + I8x16Ne, + I8x16LtS, + I8x16LtU, + I8x16GtS, + I8x16GtU, + I8x16LeS, + I8x16LeU, + I8x16GeS, + I8x16GeU, + I16x8Eq, + I16x8Ne, + I16x8LtS, + I16x8LtU, + I16x8GtS, + I16x8GtU, + I16x8LeS, + I16x8LeU, + I16x8GeS, + I16x8GeU, + I32x4Eq, + I32x4Ne, + I32x4LtS, + I32x4LtU, + I32x4GtS, + I32x4GtU, + I32x4LeS, + I32x4LeU, + I32x4GeS, + I32x4GeU, + I64x2Eq, + I64x2Ne, + I64x2LtS, + I64x2GtS, + I64x2LeS, + I64x2GeS, + F32x4Eq, + F32x4Ne, + F32x4Lt, + F32x4Gt, + F32x4Le, + F32x4Ge, + F64x2Eq, + F64x2Ne, + F64x2Lt, + F64x2Gt, + F64x2Le, + F64x2Ge, + V128Not, + V128And, + V128AndNot, + V128Or, + V128Xor, + V128Bitselect, + V128AnyTrue, + I8x16Abs, + I8x16Neg, + I8x16Popcnt, + I8x16AllTrue, + I8x16Bitmask, + I8x16NarrowI16x8S, + I8x16NarrowI16x8U, + I8x16Shl, + I8x16ShrS, + I8x16ShrU, + I8x16Add, + I8x16AddSatS, + I8x16AddSatU, + I8x16Sub, + I8x16SubSatS, + I8x16SubSatU, + I8x16MinS, + I8x16MinU, + I8x16MaxS, + I8x16MaxU, + I8x16RoundingAverageU, + I16x8ExtAddPairwiseI8x16S, + I16x8ExtAddPairwiseI8x16U, + I16x8Abs, + I16x8Neg, + I16x8Q15MulrSatS, + I16x8AllTrue, + I16x8Bitmask, + I16x8NarrowI32x4S, + I16x8NarrowI32x4U, + I16x8ExtendLowI8x16S, + I16x8ExtendHighI8x16S, + I16x8ExtendLowI8x16U, + I16x8ExtendHighI8x16U, + I16x8Shl, + I16x8ShrS, + I16x8ShrU, + I16x8Add, + I16x8AddSatS, + I16x8AddSatU, + I16x8Sub, + I16x8SubSatS, + I16x8SubSatU, + I16x8Mul, + I16x8MinS, + I16x8MinU, + I16x8MaxS, + I16x8MaxU, + I16x8RoundingAverageU, + I16x8ExtMulLowI8x16S, + I16x8ExtMulHighI8x16S, + I16x8ExtMulLowI8x16U, + I16x8ExtMulHighI8x16U, + I32x4ExtAddPairwiseI16x8S, + I32x4ExtAddPairwiseI16x8U, + I32x4Abs, + I32x4Neg, + I32x4AllTrue, + I32x4Bitmask, + I32x4ExtendLowI16x8S, + I32x4ExtendHighI16x8S, + I32x4ExtendLowI16x8U, + I32x4ExtendHighI16x8U, + I32x4Shl, + I32x4ShrS, + I32x4ShrU, + I32x4Add, + I32x4Sub, + I32x4Mul, + I32x4MinS, + I32x4MinU, + I32x4MaxS, + I32x4MaxU, + I32x4DotI16x8S, + I32x4ExtMulLowI16x8S, + I32x4ExtMulHighI16x8S, + I32x4ExtMulLowI16x8U, + I32x4ExtMulHighI16x8U, + I64x2Abs, + I64x2Neg, + I64x2AllTrue, + I64x2Bitmask, + I64x2ExtendLowI32x4S, + I64x2ExtendHighI32x4S, + I64x2ExtendLowI32x4U, + I64x2ExtendHighI32x4U, + I64x2Shl, + I64x2ShrS, + I64x2ShrU, + I64x2Add, + I64x2Sub, + I64x2Mul, + I64x2ExtMulLowI32x4S, + I64x2ExtMulHighI32x4S, + I64x2ExtMulLowI32x4U, + I64x2ExtMulHighI32x4U, + F32x4Ceil, + F32x4Floor, + F32x4Trunc, + F32x4Nearest, + F32x4Abs, + F32x4Neg, + F32x4Sqrt, + F32x4Add, + F32x4Sub, + F32x4Mul, + F32x4Div, + F32x4Min, + F32x4Max, + F32x4PMin, + F32x4PMax, + F64x2Ceil, + F64x2Floor, + F64x2Trunc, + F64x2Nearest, + F64x2Abs, + F64x2Neg, + F64x2Sqrt, + F64x2Add, + F64x2Sub, + F64x2Mul, + F64x2Div, + F64x2Min, + F64x2Max, + F64x2PMin, + F64x2PMax, + I32x4TruncSatF32x4S, + I32x4TruncSatF32x4U, + F32x4ConvertI32x4S, + F32x4ConvertI32x4U, + I32x4TruncSatF64x2SZero, + I32x4TruncSatF64x2UZero, + F64x2ConvertLowI32x4S, + F64x2ConvertLowI32x4U, + F32x4DemoteF64x2Zero, + F64x2PromoteLowF32x4, + I8x16RelaxedSwizzle, + I32x4RelaxedTruncSatF32x4S, + I32x4RelaxedTruncSatF32x4U, + I32x4RelaxedTruncSatF64x2SZero, + I32x4RelaxedTruncSatF64x2UZero, + F32x4Fma, + F32x4Fms, + F64x2Fma, + F64x2Fms, + I8x16LaneSelect, + I16x8LaneSelect, + I32x4LaneSelect, + I64x2LaneSelect, + F32x4RelaxedMin, + F32x4RelaxedMax, + F64x2RelaxedMin, + F64x2RelaxedMax, +} + +/// A reader for a core WebAssembly function's operators. +#[derive(Clone)] +pub struct OperatorsReader<'a> { + pub(crate) reader: BinaryReader<'a>, +} + +impl<'a> OperatorsReader<'a> { + pub(crate) fn new<'b>(data: &'a [u8], offset: usize) -> OperatorsReader<'b> + where + 'a: 'b, + { + OperatorsReader { + reader: BinaryReader::new_with_offset(data, offset), + } + } + + /// Determines if the reader is at the end of the operators. + pub fn eof(&self) -> bool { + self.reader.eof() + } + + /// Gets the original position of the reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Whether or not to allow 64-bit memory arguments in the + /// the operators being read. + /// + /// This is intended to be `true` when support for the memory64 + /// WebAssembly proposal is also enabled. + pub fn allow_memarg64(&mut self, allow: bool) { + self.reader.allow_memarg64(allow); + } + + /// Ensures the reader is at the end. + /// + /// This function returns an error if there is extra data after the operators. + pub fn ensure_end(&self) -> Result<()> { + if self.eof() { + return Ok(()); + } + Err(BinaryReaderError::new( + "unexpected data at the end of operators", + self.reader.original_position(), + )) + } + + /// Reads an operator from the reader. + pub fn read<'b>(&mut self) -> Result> + where + 'a: 'b, + { + self.reader.read_operator() + } + + /// Converts to an iterator of operators paired with offsets. + pub fn into_iter_with_offsets<'b>(self) -> OperatorsIteratorWithOffsets<'b> + where + 'a: 'b, + { + OperatorsIteratorWithOffsets { + reader: self, + err: false, + } + } + + /// Reads an operator with its offset. + pub fn read_with_offset<'b>(&mut self) -> Result<(Operator<'b>, usize)> + where + 'a: 'b, + { + let pos = self.reader.original_position(); + Ok((self.read()?, pos)) + } + + /// Visits an operator with its offset. + pub fn visit_with_offset( + &mut self, + visitor: &mut T, + ) -> Result<>::Output> + where + T: VisitOperator<'a>, + { + self.reader.visit_operator(visitor) + } + + /// Gets a binary reader from this operators reader. + pub fn get_binary_reader(&self) -> BinaryReader<'a> { + self.reader.clone() + } +} + +impl<'a> IntoIterator for OperatorsReader<'a> { + type Item = Result>; + type IntoIter = OperatorsIterator<'a>; + + /// Reads content of the code section. + /// + /// # Examples + /// ``` + /// use wasmparser::{Operator, CodeSectionReader, Result}; + /// # let data: &[u8] = &[ + /// # 0x01, 0x03, 0x00, 0x01, 0x0b]; + /// let mut code_reader = CodeSectionReader::new(data, 0).unwrap(); + /// for _ in 0..code_reader.get_count() { + /// let body = code_reader.read().expect("function body"); + /// let mut op_reader = body.get_operators_reader().expect("op reader"); + /// let ops = op_reader.into_iter().collect::>>().expect("ops"); + /// assert!( + /// if let [Operator::Nop, Operator::End] = ops.as_slice() { true } else { false }, + /// "found {:?}", + /// ops + /// ); + /// } + /// ``` + fn into_iter(self) -> Self::IntoIter { + OperatorsIterator { + reader: self, + err: false, + } + } +} + +/// An iterator over a function's operators. +pub struct OperatorsIterator<'a> { + reader: OperatorsReader<'a>, + err: bool, +} + +impl<'a> Iterator for OperatorsIterator<'a> { + type Item = Result>; + + fn next(&mut self) -> Option { + if self.err || self.reader.eof() { + return None; + } + let result = self.reader.read(); + self.err = result.is_err(); + Some(result) + } +} + +/// An iterator over a function's operators with offsets. +pub struct OperatorsIteratorWithOffsets<'a> { + reader: OperatorsReader<'a>, + err: bool, +} + +impl<'a> Iterator for OperatorsIteratorWithOffsets<'a> { + type Item = Result<(Operator<'a>, usize)>; + + /// Reads content of the code section with offsets. + /// + /// # Examples + /// ``` + /// use wasmparser::{Operator, CodeSectionReader, Result}; + /// # let data: &[u8] = &[ + /// # 0x01, 0x03, 0x00, /* offset = 23 */ 0x01, 0x0b]; + /// let mut code_reader = CodeSectionReader::new(data, 20).unwrap(); + /// for _ in 0..code_reader.get_count() { + /// let body = code_reader.read().expect("function body"); + /// let mut op_reader = body.get_operators_reader().expect("op reader"); + /// let ops = op_reader.into_iter_with_offsets().collect::>>().expect("ops"); + /// assert!( + /// if let [(Operator::Nop, 23), (Operator::End, 24)] = ops.as_slice() { true } else { false }, + /// "found {:?}", + /// ops + /// ); + /// } + /// ``` + fn next(&mut self) -> Option { + if self.err || self.reader.eof() { + return None; + } + let result = self.reader.read_with_offset(); + self.err = result.is_err(); + Some(result) + } +} + +/// Trait implemented by types that can visit all [`Operator`] variants. +#[allow(missing_docs)] +pub trait VisitOperator<'a> { + /// The result type of the visitor. + type Output: 'a; + + /// Visits the [`Operator`] `op` using the given `offset`. + /// + /// # Note + /// + /// This is a convenience method that is intended for non-performance + /// critical use cases. For performance critical implementations users + /// are recommended to directly use the respective `visit` methods or + /// implement [`VisitOperator`] on their own. + #[rustfmt::skip] + fn visit_operator(&mut self, offset: usize, op: &Operator<'a>) -> Self::Output { + match *op { + Operator::Unreachable => self.visit_unreachable(offset), + Operator::Nop => self.visit_nop(offset), + Operator::Block { ty } => self.visit_block(offset, ty), + Operator::Loop { ty } => self.visit_loop(offset, ty), + Operator::If { ty } => self.visit_if(offset, ty), + Operator::Else => self.visit_else(offset), + Operator::Try { ty } => self.visit_try(offset, ty), + Operator::Catch { index } => self.visit_catch(offset, index), + Operator::Throw { index } => self.visit_throw(offset, index), + Operator::Rethrow { relative_depth } => self.visit_rethrow(offset, relative_depth), + Operator::End => self.visit_end(offset), + Operator::Br { relative_depth } => self.visit_br(offset, relative_depth), + Operator::BrIf { relative_depth } => self.visit_br_if(offset, relative_depth), + Operator::BrTable { ref table } => self.visit_br_table(offset, table), + Operator::Return => self.visit_return(offset), + Operator::Call { function_index } => self.visit_call(offset, function_index), + Operator::CallIndirect { index, table_index, table_byte } => self.visit_call_indirect(offset, index, table_index, table_byte), + Operator::ReturnCall { function_index } => self.visit_return_call(offset, function_index), + Operator::ReturnCallIndirect { index, table_index } => self.visit_return_call_indirect(offset, index, table_index), + Operator::Delegate { relative_depth } => self.visit_delegate(offset, relative_depth), + Operator::CatchAll => self.visit_catch_all(offset), + Operator::Drop => self.visit_drop(offset), + Operator::Select => self.visit_select(offset), + Operator::TypedSelect { ty } => self.visit_typed_select(offset, ty), + Operator::LocalGet { local_index } => self.visit_local_get(offset, local_index), + Operator::LocalSet { local_index } => self.visit_local_set(offset, local_index), + Operator::LocalTee { local_index } => self.visit_local_tee(offset, local_index), + Operator::GlobalGet { global_index } => self.visit_global_get(offset, global_index), + Operator::GlobalSet { global_index } => self.visit_global_set(offset, global_index), + Operator::I32Load { memarg } => self.visit_i32_load(offset, memarg), + Operator::I64Load { memarg } => self.visit_i64_load(offset, memarg), + Operator::F32Load { memarg } => self.visit_f32_load(offset, memarg), + Operator::F64Load { memarg } => self.visit_f64_load(offset, memarg), + Operator::I32Load8S { memarg } => self.visit_i32_load8_s(offset, memarg), + Operator::I32Load8U { memarg } => self.visit_i32_load8_u(offset, memarg), + Operator::I32Load16S { memarg } => self.visit_i32_load16_s(offset, memarg), + Operator::I32Load16U { memarg } => self.visit_i32_load16_u(offset, memarg), + Operator::I64Load8S { memarg } => self.visit_i64_load8_s(offset, memarg), + Operator::I64Load8U { memarg } => self.visit_i64_load8_u(offset, memarg), + Operator::I64Load16S { memarg } => self.visit_i64_load16_s(offset, memarg), + Operator::I64Load16U { memarg } => self.visit_i64_load16_u(offset, memarg), + Operator::I64Load32S { memarg } => self.visit_i64_load32_s(offset, memarg), + Operator::I64Load32U { memarg } => self.visit_i64_load32_u(offset, memarg), + Operator::I32Store { memarg } => self.visit_i32_store(offset, memarg), + Operator::I64Store { memarg } => self.visit_i64_store(offset, memarg), + Operator::F32Store { memarg } => self.visit_f32_store(offset, memarg), + Operator::F64Store { memarg } => self.visit_f64_store(offset, memarg), + Operator::I32Store8 { memarg } => self.visit_i32_store8(offset, memarg), + Operator::I32Store16 { memarg } => self.visit_i32_store16(offset, memarg), + Operator::I64Store8 { memarg } => self.visit_i64_store8(offset, memarg), + Operator::I64Store16 { memarg } => self.visit_i64_store16(offset, memarg), + Operator::I64Store32 { memarg } => self.visit_i64_store32(offset, memarg), + Operator::MemorySize { mem, mem_byte } => self.visit_memory_size(offset, mem, mem_byte), + Operator::MemoryGrow { mem, mem_byte } => self.visit_memory_grow(offset, mem, mem_byte), + Operator::I32Const { value } => self.visit_i32_const(offset, value), + Operator::I64Const { value } => self.visit_i64_const(offset, value), + Operator::F32Const { value } => self.visit_f32_const(offset, value), + Operator::F64Const { value } => self.visit_f64_const(offset, value), + Operator::RefNull { ty } => self.visit_ref_null(offset, ty), + Operator::RefIsNull => self.visit_ref_is_null(offset), + Operator::RefFunc { function_index } => self.visit_ref_func(offset, function_index), + Operator::I32Eqz => self.visit_i32_eqz(offset), + Operator::I32Eq => self.visit_i32_eq(offset), + Operator::I32Ne => self.visit_i32_ne(offset), + Operator::I32LtS => self.visit_i32_lt_s(offset), + Operator::I32LtU => self.visit_i32_lt_u(offset), + Operator::I32GtS => self.visit_i32_gt_s(offset), + Operator::I32GtU => self.visit_i32_gt_u(offset), + Operator::I32LeS => self.visit_i32_le_s(offset), + Operator::I32LeU => self.visit_i32_le_u(offset), + Operator::I32GeS => self.visit_i32_ge_s(offset), + Operator::I32GeU => self.visit_i32_ge_u(offset), + Operator::I64Eqz => self.visit_i64_eqz(offset), + Operator::I64Eq => self.visit_i64_eq(offset), + Operator::I64Ne => self.visit_i64_ne(offset), + Operator::I64LtS => self.visit_i64_lt_s(offset), + Operator::I64LtU => self.visit_i64_lt_u(offset), + Operator::I64GtS => self.visit_i64_gt_s(offset), + Operator::I64GtU => self.visit_i64_gt_u(offset), + Operator::I64LeS => self.visit_i64_le_s(offset), + Operator::I64LeU => self.visit_i64_le_u(offset), + Operator::I64GeS => self.visit_i64_ge_s(offset), + Operator::I64GeU => self.visit_i64_ge_u(offset), + Operator::F32Eq => self.visit_f32_eq(offset), + Operator::F32Ne => self.visit_f32_ne(offset), + Operator::F32Lt => self.visit_f32_lt(offset), + Operator::F32Gt => self.visit_f32_gt(offset), + Operator::F32Le => self.visit_f32_le(offset), + Operator::F32Ge => self.visit_f32_ge(offset), + Operator::F64Eq => self.visit_f64_eq(offset), + Operator::F64Ne => self.visit_f64_ne(offset), + Operator::F64Lt => self.visit_f64_lt(offset), + Operator::F64Gt => self.visit_f64_gt(offset), + Operator::F64Le => self.visit_f64_le(offset), + Operator::F64Ge => self.visit_f64_ge(offset), + Operator::I32Clz => self.visit_i32_clz(offset), + Operator::I32Ctz => self.visit_i32_ctz(offset), + Operator::I32Popcnt => self.visit_i32_popcnt(offset), + Operator::I32Add => self.visit_i32_add(offset), + Operator::I32Sub => self.visit_i32_sub(offset), + Operator::I32Mul => self.visit_i32_mul(offset), + Operator::I32DivS => self.visit_i32_div_s(offset), + Operator::I32DivU => self.visit_i32_div_u(offset), + Operator::I32RemS => self.visit_i32_rem_s(offset), + Operator::I32RemU => self.visit_i32_rem_u(offset), + Operator::I32And => self.visit_i32_and(offset), + Operator::I32Or => self.visit_i32_or(offset), + Operator::I32Xor => self.visit_i32_xor(offset), + Operator::I32Shl => self.visit_i32_shl(offset), + Operator::I32ShrS => self.visit_i32_shr_s(offset), + Operator::I32ShrU => self.visit_i32_shr_u(offset), + Operator::I32Rotl => self.visit_i32_rotl(offset), + Operator::I32Rotr => self.visit_i32_rotr(offset), + Operator::I64Clz => self.visit_i64_clz(offset), + Operator::I64Ctz => self.visit_i64_ctz(offset), + Operator::I64Popcnt => self.visit_i64_popcnt(offset), + Operator::I64Add => self.visit_i64_add(offset), + Operator::I64Sub => self.visit_i64_sub(offset), + Operator::I64Mul => self.visit_i64_mul(offset), + Operator::I64DivS => self.visit_i64_div_s(offset), + Operator::I64DivU => self.visit_i64_div_u(offset), + Operator::I64RemS => self.visit_i64_rem_s(offset), + Operator::I64RemU => self.visit_i64_rem_u(offset), + Operator::I64And => self.visit_i64_and(offset), + Operator::I64Or => self.visit_i64_or(offset), + Operator::I64Xor => self.visit_i64_xor(offset), + Operator::I64Shl => self.visit_i64_shl(offset), + Operator::I64ShrS => self.visit_i64_shr_s(offset), + Operator::I64ShrU => self.visit_i64_shr_u(offset), + Operator::I64Rotl => self.visit_i64_rotl(offset), + Operator::I64Rotr => self.visit_i64_rotr(offset), + Operator::F32Abs => self.visit_f32_abs(offset), + Operator::F32Neg => self.visit_f32_neg(offset), + Operator::F32Ceil => self.visit_f32_ceil(offset), + Operator::F32Floor => self.visit_f32_floor(offset), + Operator::F32Trunc => self.visit_f32_trunc(offset), + Operator::F32Nearest => self.visit_f32_nearest(offset), + Operator::F32Sqrt => self.visit_f32_sqrt(offset), + Operator::F32Add => self.visit_f32_add(offset), + Operator::F32Sub => self.visit_f32_sub(offset), + Operator::F32Mul => self.visit_f32_mul(offset), + Operator::F32Div => self.visit_f32_div(offset), + Operator::F32Min => self.visit_f32_min(offset), + Operator::F32Max => self.visit_f32_max(offset), + Operator::F32Copysign => self.visit_f32_copysign(offset), + Operator::F64Abs => self.visit_f64_abs(offset), + Operator::F64Neg => self.visit_f64_neg(offset), + Operator::F64Ceil => self.visit_f64_ceil(offset), + Operator::F64Floor => self.visit_f64_floor(offset), + Operator::F64Trunc => self.visit_f64_trunc(offset), + Operator::F64Nearest => self.visit_f64_nearest(offset), + Operator::F64Sqrt => self.visit_f64_sqrt(offset), + Operator::F64Add => self.visit_f64_add(offset), + Operator::F64Sub => self.visit_f64_sub(offset), + Operator::F64Mul => self.visit_f64_mul(offset), + Operator::F64Div => self.visit_f64_div(offset), + Operator::F64Min => self.visit_f64_min(offset), + Operator::F64Max => self.visit_f64_max(offset), + Operator::F64Copysign => self.visit_f64_copysign(offset), + Operator::I32WrapI64 => self.visit_i32_wrap_i64(offset), + Operator::I32TruncF32S => self.visit_i32_trunc_f32s(offset), + Operator::I32TruncF32U => self.visit_i32_trunc_f32u(offset), + Operator::I32TruncF64S => self.visit_i32_trunc_f64s(offset), + Operator::I32TruncF64U => self.visit_i32_trunc_f64u(offset), + Operator::I64ExtendI32S => self.visit_i64_extend_i32s(offset), + Operator::I64ExtendI32U => self.visit_i64_extend_i32u(offset), + Operator::I64TruncF32S => self.visit_i64_trunc_f32s(offset), + Operator::I64TruncF32U => self.visit_i64_trunc_f32u(offset), + Operator::I64TruncF64S => self.visit_i64_trunc_f64s(offset), + Operator::I64TruncF64U => self.visit_i64_trunc_f64u(offset), + Operator::F32ConvertI32S => self.visit_f32_convert_i32s(offset), + Operator::F32ConvertI32U => self.visit_f32_convert_i32u(offset), + Operator::F32ConvertI64S => self.visit_f32_convert_i64s(offset), + Operator::F32ConvertI64U => self.visit_f32_convert_i64u(offset), + Operator::F32DemoteF64 => self.visit_f32_demote_f64(offset), + Operator::F64ConvertI32S => self.visit_f64_convert_i32s(offset), + Operator::F64ConvertI32U => self.visit_f64_convert_i32u(offset), + Operator::F64ConvertI64S => self.visit_f64_convert_i64s(offset), + Operator::F64ConvertI64U => self.visit_f64_convert_i64u(offset), + Operator::F64PromoteF32 => self.visit_f64_promote_f32(offset), + Operator::I32ReinterpretF32 => self.visit_i32_reinterpret_f32(offset), + Operator::I64ReinterpretF64 => self.visit_i64_reinterpret_f64(offset), + Operator::F32ReinterpretI32 => self.visit_f32_reinterpret_i32(offset), + Operator::F64ReinterpretI64 => self.visit_f64_reinterpret_i64(offset), + Operator::I32Extend8S => self.visit_i32_extend8_s(offset), + Operator::I32Extend16S => self.visit_i32_extend16_s(offset), + Operator::I64Extend8S => self.visit_i64_extend8_s(offset), + Operator::I64Extend16S => self.visit_i64_extend16_s(offset), + Operator::I64Extend32S => self.visit_i64_extend32_s(offset), + Operator::I32TruncSatF32S => self.visit_i32_trunc_sat_f32s(offset), + Operator::I32TruncSatF32U => self.visit_i32_trunc_sat_f32u(offset), + Operator::I32TruncSatF64S => self.visit_i32_trunc_sat_f64s(offset), + Operator::I32TruncSatF64U => self.visit_i32_trunc_sat_f64u(offset), + Operator::I64TruncSatF32S => self.visit_i64_trunc_sat_f32s(offset), + Operator::I64TruncSatF32U => self.visit_i64_trunc_sat_f32u(offset), + Operator::I64TruncSatF64S => self.visit_i64_trunc_sat_f64s(offset), + Operator::I64TruncSatF64U => self.visit_i64_trunc_sat_f64u(offset), + Operator::MemoryInit { segment, mem } => self.visit_memory_init(offset, segment, mem), + Operator::DataDrop { segment } => self.visit_data_drop(offset, segment), + Operator::MemoryCopy { src, dst } => self.visit_memory_copy(offset, dst, src), + Operator::MemoryFill { mem } => self.visit_memory_fill(offset, mem), + Operator::TableInit { segment, table } => self.visit_table_init(offset, segment, table), + Operator::ElemDrop { segment } => self.visit_elem_drop(offset, segment), + Operator::TableCopy { dst_table, src_table } => self.visit_table_copy(offset, dst_table, src_table), + Operator::TableFill { table } => self.visit_table_fill(offset, table), + Operator::TableGet { table } => self.visit_table_get(offset, table), + Operator::TableSet { table } => self.visit_table_set(offset, table), + Operator::TableGrow { table } => self.visit_table_grow(offset, table), + Operator::TableSize { table } => self.visit_table_size(offset, table), + Operator::MemoryAtomicNotify { memarg } => self.visit_memory_atomic_notify(offset, memarg), + Operator::MemoryAtomicWait32 { memarg } => self.visit_memory_atomic_wait32(offset, memarg), + Operator::MemoryAtomicWait64 { memarg } => self.visit_memory_atomic_wait64(offset, memarg), + Operator::AtomicFence { flags } => self.visit_atomic_fence(offset, flags), + Operator::I32AtomicLoad { memarg } => self.visit_i32_atomic_load(offset, memarg), + Operator::I64AtomicLoad { memarg } => self.visit_i64_atomic_load(offset, memarg), + Operator::I32AtomicLoad8U { memarg } => self.visit_i32_atomic_load8_u(offset, memarg), + Operator::I32AtomicLoad16U { memarg } => self.visit_i32_atomic_load16_u(offset, memarg), + Operator::I64AtomicLoad8U { memarg } => self.visit_i64_atomic_load8_u(offset, memarg), + Operator::I64AtomicLoad16U { memarg } => self.visit_i64_atomic_load16_u(offset, memarg), + Operator::I64AtomicLoad32U { memarg } => self.visit_i64_atomic_load32_u(offset, memarg), + Operator::I32AtomicStore { memarg } => self.visit_i32_atomic_store(offset, memarg), + Operator::I64AtomicStore { memarg } => self.visit_i64_atomic_store(offset, memarg), + Operator::I32AtomicStore8 { memarg } => self.visit_i32_atomic_store8(offset, memarg), + Operator::I32AtomicStore16 { memarg } => self.visit_i32_atomic_store16(offset, memarg), + Operator::I64AtomicStore8 { memarg } => self.visit_i64_atomic_store8(offset, memarg), + Operator::I64AtomicStore16 { memarg } => self.visit_i64_atomic_store16(offset, memarg), + Operator::I64AtomicStore32 { memarg } => self.visit_i64_atomic_store32(offset, memarg), + Operator::I32AtomicRmwAdd { memarg } => self.visit_i32_atomic_rmw_add(offset, memarg), + Operator::I64AtomicRmwAdd { memarg } => self.visit_i64_atomic_rmw_add(offset, memarg), + Operator::I32AtomicRmw8AddU { memarg } => self.visit_i32_atomic_rmw8_add_u(offset, memarg), + Operator::I32AtomicRmw16AddU { memarg } => self.visit_i32_atomic_rmw16_add_u(offset, memarg), + Operator::I64AtomicRmw8AddU { memarg } => self.visit_i64_atomic_rmw8_add_u(offset, memarg), + Operator::I64AtomicRmw16AddU { memarg } => self.visit_i64_atomic_rmw16_add_u(offset, memarg), + Operator::I64AtomicRmw32AddU { memarg } => self.visit_i64_atomic_rmw32_add_u(offset, memarg), + Operator::I32AtomicRmwSub { memarg } => self.visit_i32_atomic_rmw_sub(offset, memarg), + Operator::I64AtomicRmwSub { memarg } => self.visit_i64_atomic_rmw_sub(offset, memarg), + Operator::I32AtomicRmw8SubU { memarg } => self.visit_i32_atomic_rmw8_sub_u(offset, memarg), + Operator::I32AtomicRmw16SubU { memarg } => self.visit_i32_atomic_rmw16_sub_u(offset, memarg), + Operator::I64AtomicRmw8SubU { memarg } => self.visit_i64_atomic_rmw8_sub_u(offset, memarg), + Operator::I64AtomicRmw16SubU { memarg } => self.visit_i64_atomic_rmw16_sub_u(offset, memarg), + Operator::I64AtomicRmw32SubU { memarg } => self.visit_i64_atomic_rmw32_sub_u(offset, memarg), + Operator::I32AtomicRmwAnd { memarg } => self.visit_i32_atomic_rmw_and(offset, memarg), + Operator::I64AtomicRmwAnd { memarg } => self.visit_i64_atomic_rmw_and(offset, memarg), + Operator::I32AtomicRmw8AndU { memarg } => self.visit_i32_atomic_rmw8_and_u(offset, memarg), + Operator::I32AtomicRmw16AndU { memarg } => self.visit_i32_atomic_rmw16_and_u(offset, memarg), + Operator::I64AtomicRmw8AndU { memarg } => self.visit_i64_atomic_rmw8_and_u(offset, memarg), + Operator::I64AtomicRmw16AndU { memarg } => self.visit_i64_atomic_rmw16_and_u(offset, memarg), + Operator::I64AtomicRmw32AndU { memarg } => self.visit_i64_atomic_rmw32_and_u(offset, memarg), + Operator::I32AtomicRmwOr { memarg } => self.visit_i32_atomic_rmw_or(offset, memarg), + Operator::I64AtomicRmwOr { memarg } => self.visit_i64_atomic_rmw_or(offset, memarg), + Operator::I32AtomicRmw8OrU { memarg } => self.visit_i32_atomic_rmw8_or_u(offset, memarg), + Operator::I32AtomicRmw16OrU { memarg } => self.visit_i32_atomic_rmw16_or_u(offset, memarg), + Operator::I64AtomicRmw8OrU { memarg } => self.visit_i64_atomic_rmw8_or_u(offset, memarg), + Operator::I64AtomicRmw16OrU { memarg } => self.visit_i64_atomic_rmw16_or_u(offset, memarg), + Operator::I64AtomicRmw32OrU { memarg } => self.visit_i64_atomic_rmw32_or_u(offset, memarg), + Operator::I32AtomicRmwXor { memarg } => self.visit_i32_atomic_rmw_xor(offset, memarg), + Operator::I64AtomicRmwXor { memarg } => self.visit_i64_atomic_rmw_xor(offset, memarg), + Operator::I32AtomicRmw8XorU { memarg } => self.visit_i32_atomic_rmw8_xor_u(offset, memarg), + Operator::I32AtomicRmw16XorU { memarg } => self.visit_i32_atomic_rmw16_xor_u(offset, memarg), + Operator::I64AtomicRmw8XorU { memarg } => self.visit_i64_atomic_rmw8_xor_u(offset, memarg), + Operator::I64AtomicRmw16XorU { memarg } => self.visit_i64_atomic_rmw16_xor_u(offset, memarg), + Operator::I64AtomicRmw32XorU { memarg } => self.visit_i64_atomic_rmw32_xor_u(offset, memarg), + Operator::I32AtomicRmwXchg { memarg } => self.visit_i32_atomic_rmw_xchg(offset, memarg), + Operator::I64AtomicRmwXchg { memarg } => self.visit_i64_atomic_rmw_xchg(offset, memarg), + Operator::I32AtomicRmw8XchgU { memarg } => self.visit_i32_atomic_rmw8_xchg_u(offset, memarg), + Operator::I32AtomicRmw16XchgU { memarg } => self.visit_i32_atomic_rmw16_xchg_u(offset, memarg), + Operator::I64AtomicRmw8XchgU { memarg } => self.visit_i64_atomic_rmw8_xchg_u(offset, memarg), + Operator::I64AtomicRmw16XchgU { memarg } => self.visit_i64_atomic_rmw16_xchg_u(offset, memarg), + Operator::I64AtomicRmw32XchgU { memarg } => self.visit_i64_atomic_rmw32_xchg_u(offset, memarg), + Operator::I32AtomicRmwCmpxchg { memarg } => self.visit_i32_atomic_rmw_cmpxchg(offset, memarg), + Operator::I64AtomicRmwCmpxchg { memarg } => self.visit_i64_atomic_rmw_cmpxchg(offset, memarg), + Operator::I32AtomicRmw8CmpxchgU { memarg } => self.visit_i32_atomic_rmw8_cmpxchg_u(offset, memarg), + Operator::I32AtomicRmw16CmpxchgU { memarg } => self.visit_i32_atomic_rmw16_cmpxchg_u(offset, memarg), + Operator::I64AtomicRmw8CmpxchgU { memarg } => self.visit_i64_atomic_rmw8_cmpxchg_u(offset, memarg), + Operator::I64AtomicRmw16CmpxchgU { memarg } => self.visit_i64_atomic_rmw16_cmpxchg_u(offset, memarg), + Operator::I64AtomicRmw32CmpxchgU { memarg } => self.visit_i64_atomic_rmw32_cmpxchg_u(offset, memarg), + Operator::V128Load { memarg } => self.visit_v128_load(offset, memarg), + Operator::V128Load8x8S { memarg } => self.visit_v128_load8x8_s(offset, memarg), + Operator::V128Load8x8U { memarg } => self.visit_v128_load8x8_u(offset, memarg), + Operator::V128Load16x4S { memarg } => self.visit_v128_load16x4_s(offset, memarg), + Operator::V128Load16x4U { memarg } => self.visit_v128_load16x4_u(offset, memarg), + Operator::V128Load32x2S { memarg } => self.visit_v128_load32x2_s(offset, memarg), + Operator::V128Load32x2U { memarg } => self.visit_v128_load32x2_u(offset, memarg), + Operator::V128Load8Splat { memarg } => self.visit_v128_load8_splat(offset, memarg), + Operator::V128Load16Splat { memarg } => self.visit_v128_load16_splat(offset, memarg), + Operator::V128Load32Splat { memarg } => self.visit_v128_load32_splat(offset, memarg), + Operator::V128Load64Splat { memarg } => self.visit_v128_load64_splat(offset, memarg), + Operator::V128Load32Zero { memarg } => self.visit_v128_load32_zero(offset, memarg), + Operator::V128Load64Zero { memarg } => self.visit_v128_load64_zero(offset, memarg), + Operator::V128Store { memarg } => self.visit_v128_store(offset, memarg), + Operator::V128Load8Lane { memarg, lane } => self.visit_v128_load8_lane(offset, memarg, lane), + Operator::V128Load16Lane { memarg, lane } => self.visit_v128_load16_lane(offset, memarg, lane), + Operator::V128Load32Lane { memarg, lane } => self.visit_v128_load32_lane(offset, memarg, lane), + Operator::V128Load64Lane { memarg, lane } => self.visit_v128_load64_lane(offset, memarg, lane), + Operator::V128Store8Lane { memarg, lane } => self.visit_v128_store8_lane(offset, memarg, lane), + Operator::V128Store16Lane { memarg, lane } => self.visit_v128_store16_lane(offset, memarg, lane), + Operator::V128Store32Lane { memarg, lane } => self.visit_v128_store32_lane(offset, memarg, lane), + Operator::V128Store64Lane { memarg, lane } => self.visit_v128_store64_lane(offset, memarg, lane), + Operator::V128Const { value } => self.visit_v128_const(offset, value), + Operator::I8x16Shuffle { lanes } => self.visit_i8x16_shuffle(offset, lanes), + Operator::I8x16ExtractLaneS { lane } => self.visit_i8x16_extract_lane_s(offset, lane), + Operator::I8x16ExtractLaneU { lane } => self.visit_i8x16_extract_lane_u(offset, lane), + Operator::I8x16ReplaceLane { lane } => self.visit_i8x16_replace_lane(offset, lane), + Operator::I16x8ExtractLaneS { lane } => self.visit_i16x8_extract_lane_s(offset, lane), + Operator::I16x8ExtractLaneU { lane } => self.visit_i16x8_extract_lane_u(offset, lane), + Operator::I16x8ReplaceLane { lane } => self.visit_i16x8_replace_lane(offset, lane), + Operator::I32x4ExtractLane { lane } => self.visit_i32x4_extract_lane(offset, lane), + Operator::I32x4ReplaceLane { lane } => self.visit_i32x4_replace_lane(offset, lane), + Operator::I64x2ExtractLane { lane } => self.visit_i64x2_extract_lane(offset, lane), + Operator::I64x2ReplaceLane { lane } => self.visit_i64x2_replace_lane(offset, lane), + Operator::F32x4ExtractLane { lane } => self.visit_f32x4_extract_lane(offset, lane), + Operator::F32x4ReplaceLane { lane } => self.visit_f32x4_replace_lane(offset, lane), + Operator::F64x2ExtractLane { lane } => self.visit_f64x2_extract_lane(offset, lane), + Operator::F64x2ReplaceLane { lane } => self.visit_f64x2_replace_lane(offset, lane), + Operator::I8x16Swizzle => self.visit_i8x16_swizzle(offset), + Operator::I8x16Splat => self.visit_i8x16_splat(offset), + Operator::I16x8Splat => self.visit_i16x8_splat(offset), + Operator::I32x4Splat => self.visit_i32x4_splat(offset), + Operator::I64x2Splat => self.visit_i64x2_splat(offset), + Operator::F32x4Splat => self.visit_f32x4_splat(offset), + Operator::F64x2Splat => self.visit_f64x2_splat(offset), + Operator::I8x16Eq => self.visit_i8x16_eq(offset), + Operator::I8x16Ne => self.visit_i8x16_ne(offset), + Operator::I8x16LtS => self.visit_i8x16_lt_s(offset), + Operator::I8x16LtU => self.visit_i8x16_lt_u(offset), + Operator::I8x16GtS => self.visit_i8x16_gt_s(offset), + Operator::I8x16GtU => self.visit_i8x16_gt_u(offset), + Operator::I8x16LeS => self.visit_i8x16_le_s(offset), + Operator::I8x16LeU => self.visit_i8x16_le_u(offset), + Operator::I8x16GeS => self.visit_i8x16_ge_s(offset), + Operator::I8x16GeU => self.visit_i8x16_ge_u(offset), + Operator::I16x8Eq => self.visit_i16x8_eq(offset), + Operator::I16x8Ne => self.visit_i16x8_ne(offset), + Operator::I16x8LtS => self.visit_i16x8_lt_s(offset), + Operator::I16x8LtU => self.visit_i16x8_lt_u(offset), + Operator::I16x8GtS => self.visit_i16x8_gt_s(offset), + Operator::I16x8GtU => self.visit_i16x8_gt_u(offset), + Operator::I16x8LeS => self.visit_i16x8_le_s(offset), + Operator::I16x8LeU => self.visit_i16x8_le_u(offset), + Operator::I16x8GeS => self.visit_i16x8_ge_s(offset), + Operator::I16x8GeU => self.visit_i16x8_ge_u(offset), + Operator::I32x4Eq => self.visit_i32x4_eq(offset), + Operator::I32x4Ne => self.visit_i32x4_ne(offset), + Operator::I32x4LtS => self.visit_i32x4_lt_s(offset), + Operator::I32x4LtU => self.visit_i32x4_lt_u(offset), + Operator::I32x4GtS => self.visit_i32x4_gt_s(offset), + Operator::I32x4GtU => self.visit_i32x4_gt_u(offset), + Operator::I32x4LeS => self.visit_i32x4_le_s(offset), + Operator::I32x4LeU => self.visit_i32x4_le_u(offset), + Operator::I32x4GeS => self.visit_i32x4_ge_s(offset), + Operator::I32x4GeU => self.visit_i32x4_ge_u(offset), + Operator::I64x2Eq => self.visit_i64x2_eq(offset), + Operator::I64x2Ne => self.visit_i64x2_ne(offset), + Operator::I64x2LtS => self.visit_i64x2_lt_s(offset), + Operator::I64x2GtS => self.visit_i64x2_gt_s(offset), + Operator::I64x2LeS => self.visit_i64x2_le_s(offset), + Operator::I64x2GeS => self.visit_i64x2_ge_s(offset), + Operator::F32x4Eq => self.visit_f32x4_eq(offset), + Operator::F32x4Ne => self.visit_f32x4_ne(offset), + Operator::F32x4Lt => self.visit_f32x4_lt(offset), + Operator::F32x4Gt => self.visit_f32x4_gt(offset), + Operator::F32x4Le => self.visit_f32x4_le(offset), + Operator::F32x4Ge => self.visit_f32x4_ge(offset), + Operator::F64x2Eq => self.visit_f64x2_eq(offset), + Operator::F64x2Ne => self.visit_f64x2_ne(offset), + Operator::F64x2Lt => self.visit_f64x2_lt(offset), + Operator::F64x2Gt => self.visit_f64x2_gt(offset), + Operator::F64x2Le => self.visit_f64x2_le(offset), + Operator::F64x2Ge => self.visit_f64x2_ge(offset), + Operator::V128Not => self.visit_v128_not(offset), + Operator::V128And => self.visit_v128_and(offset), + Operator::V128AndNot => self.visit_v128_and_not(offset), + Operator::V128Or => self.visit_v128_or(offset), + Operator::V128Xor => self.visit_v128_xor(offset), + Operator::V128Bitselect => self.visit_v128_bitselect(offset), + Operator::V128AnyTrue => self.visit_v128_any_true(offset), + Operator::I8x16Abs => self.visit_i8x16_abs(offset), + Operator::I8x16Neg => self.visit_i8x16_neg(offset), + Operator::I8x16Popcnt => self.visit_i8x16_popcnt(offset), + Operator::I8x16AllTrue => self.visit_i8x16_all_true(offset), + Operator::I8x16Bitmask => self.visit_i8x16_bitmask(offset), + Operator::I8x16NarrowI16x8S => self.visit_i8x16_narrow_i16x8_s(offset), + Operator::I8x16NarrowI16x8U => self.visit_i8x16_narrow_i16x8_u(offset), + Operator::I8x16Shl => self.visit_i8x16_shl(offset), + Operator::I8x16ShrS => self.visit_i8x16_shr_s(offset), + Operator::I8x16ShrU => self.visit_i8x16_shr_u(offset), + Operator::I8x16Add => self.visit_i8x16_add(offset), + Operator::I8x16AddSatS => self.visit_i8x16_add_sat_s(offset), + Operator::I8x16AddSatU => self.visit_i8x16_add_sat_u(offset), + Operator::I8x16Sub => self.visit_i8x16_sub(offset), + Operator::I8x16SubSatS => self.visit_i8x16_sub_sat_s(offset), + Operator::I8x16SubSatU => self.visit_i8x16_sub_sat_u(offset), + Operator::I8x16MinS => self.visit_i8x16_min_s(offset), + Operator::I8x16MinU => self.visit_i8x16_min_u(offset), + Operator::I8x16MaxS => self.visit_i8x16_max_s(offset), + Operator::I8x16MaxU => self.visit_i8x16_max_u(offset), + Operator::I8x16RoundingAverageU => self.visit_i8x16_rounding_average_u(offset), + Operator::I16x8ExtAddPairwiseI8x16S => self.visit_i16x8_ext_add_pairwise_i8x16_s(offset), + Operator::I16x8ExtAddPairwiseI8x16U => self.visit_i16x8_ext_add_pairwise_i8x16_u(offset), + Operator::I16x8Abs => self.visit_i16x8_abs(offset), + Operator::I16x8Neg => self.visit_i16x8_neg(offset), + Operator::I16x8Q15MulrSatS => self.visit_i16x8_q15_mulr_sat_s(offset), + Operator::I16x8AllTrue => self.visit_i16x8_all_true(offset), + Operator::I16x8Bitmask => self.visit_i16x8_bitmask(offset), + Operator::I16x8NarrowI32x4S => self.visit_i16x8_narrow_i32x4_s(offset), + Operator::I16x8NarrowI32x4U => self.visit_i16x8_narrow_i32x4_u(offset), + Operator::I16x8ExtendLowI8x16S => self.visit_i16x8_extend_low_i8x16_s(offset), + Operator::I16x8ExtendHighI8x16S => self.visit_i16x8_extend_high_i8x16_s(offset), + Operator::I16x8ExtendLowI8x16U => self.visit_i16x8_extend_low_i8x16_u(offset), + Operator::I16x8ExtendHighI8x16U => self.visit_i16x8_extend_high_i8x16_u(offset), + Operator::I16x8Shl => self.visit_i16x8_shl(offset), + Operator::I16x8ShrS => self.visit_i16x8_shr_s(offset), + Operator::I16x8ShrU => self.visit_i16x8_shr_u(offset), + Operator::I16x8Add => self.visit_i16x8_add(offset), + Operator::I16x8AddSatS => self.visit_i16x8_add_sat_s(offset), + Operator::I16x8AddSatU => self.visit_i16x8_add_sat_u(offset), + Operator::I16x8Sub => self.visit_i16x8_sub(offset), + Operator::I16x8SubSatS => self.visit_i16x8_sub_sat_s(offset), + Operator::I16x8SubSatU => self.visit_i16x8_sub_sat_u(offset), + Operator::I16x8Mul => self.visit_i16x8_mul(offset), + Operator::I16x8MinS => self.visit_i16x8_min_s(offset), + Operator::I16x8MinU => self.visit_i16x8_min_u(offset), + Operator::I16x8MaxS => self.visit_i16x8_max_s(offset), + Operator::I16x8MaxU => self.visit_i16x8_max_u(offset), + Operator::I16x8RoundingAverageU => self.visit_i16x8_rounding_average_u(offset), + Operator::I16x8ExtMulLowI8x16S => self.visit_i16x8_ext_mul_low_i8x16_s(offset), + Operator::I16x8ExtMulHighI8x16S => self.visit_i16x8_ext_mul_high_i8x16_s(offset), + Operator::I16x8ExtMulLowI8x16U => self.visit_i16x8_ext_mul_low_i8x16_u(offset), + Operator::I16x8ExtMulHighI8x16U => self.visit_i16x8_ext_mul_high_i8x16_u(offset), + Operator::I32x4ExtAddPairwiseI16x8S => self.visit_i32x4_ext_add_pairwise_i16x8_s(offset), + Operator::I32x4ExtAddPairwiseI16x8U => self.visit_i32x4_ext_add_pairwise_i16x8_u(offset), + Operator::I32x4Abs => self.visit_i32x4_abs(offset), + Operator::I32x4Neg => self.visit_i32x4_neg(offset), + Operator::I32x4AllTrue => self.visit_i32x4_all_true(offset), + Operator::I32x4Bitmask => self.visit_i32x4_bitmask(offset), + Operator::I32x4ExtendLowI16x8S => self.visit_i32x4_extend_low_i16x8_s(offset), + Operator::I32x4ExtendHighI16x8S => self.visit_i32x4_extend_high_i16x8_s(offset), + Operator::I32x4ExtendLowI16x8U => self.visit_i32x4_extend_low_i16x8_u(offset), + Operator::I32x4ExtendHighI16x8U => self.visit_i32x4_extend_high_i16x8_u(offset), + Operator::I32x4Shl => self.visit_i32x4_shl(offset), + Operator::I32x4ShrS => self.visit_i32x4_shr_s(offset), + Operator::I32x4ShrU => self.visit_i32x4_shr_u(offset), + Operator::I32x4Add => self.visit_i32x4_add(offset), + Operator::I32x4Sub => self.visit_i32x4_sub(offset), + Operator::I32x4Mul => self.visit_i32x4_mul(offset), + Operator::I32x4MinS => self.visit_i32x4_min_s(offset), + Operator::I32x4MinU => self.visit_i32x4_min_u(offset), + Operator::I32x4MaxS => self.visit_i32x4_max_s(offset), + Operator::I32x4MaxU => self.visit_i32x4_max_u(offset), + Operator::I32x4DotI16x8S => self.visit_i32x4_dot_i16x8_s(offset), + Operator::I32x4ExtMulLowI16x8S => self.visit_i32x4_ext_mul_low_i16x8_s(offset), + Operator::I32x4ExtMulHighI16x8S => self.visit_i32x4_ext_mul_high_i16x8_s(offset), + Operator::I32x4ExtMulLowI16x8U => self.visit_i32x4_ext_mul_low_i16x8_u(offset), + Operator::I32x4ExtMulHighI16x8U => self.visit_i32x4_ext_mul_high_i16x8_u(offset), + Operator::I64x2Abs => self.visit_i64x2_abs(offset), + Operator::I64x2Neg => self.visit_i64x2_neg(offset), + Operator::I64x2AllTrue => self.visit_i64x2_all_true(offset), + Operator::I64x2Bitmask => self.visit_i64x2_bitmask(offset), + Operator::I64x2ExtendLowI32x4S => self.visit_i64x2_extend_low_i32x4_s(offset), + Operator::I64x2ExtendHighI32x4S => self.visit_i64x2_extend_high_i32x4_s(offset), + Operator::I64x2ExtendLowI32x4U => self.visit_i64x2_extend_low_i32x4_u(offset), + Operator::I64x2ExtendHighI32x4U => self.visit_i64x2_extend_high_i32x4_u(offset), + Operator::I64x2Shl => self.visit_i64x2_shl(offset), + Operator::I64x2ShrS => self.visit_i64x2_shr_s(offset), + Operator::I64x2ShrU => self.visit_i64x2_shr_u(offset), + Operator::I64x2Add => self.visit_i64x2_add(offset), + Operator::I64x2Sub => self.visit_i64x2_sub(offset), + Operator::I64x2Mul => self.visit_i64x2_mul(offset), + Operator::I64x2ExtMulLowI32x4S => self.visit_i64x2_ext_mul_low_i32x4_s(offset), + Operator::I64x2ExtMulHighI32x4S => self.visit_i64x2_ext_mul_high_i32x4_s(offset), + Operator::I64x2ExtMulLowI32x4U => self.visit_i64x2_ext_mul_low_i32x4_u(offset), + Operator::I64x2ExtMulHighI32x4U => self.visit_i64x2_ext_mul_high_i32x4_u(offset), + Operator::F32x4Ceil => self.visit_f32x4_ceil(offset), + Operator::F32x4Floor => self.visit_f32x4_floor(offset), + Operator::F32x4Trunc => self.visit_f32x4_trunc(offset), + Operator::F32x4Nearest => self.visit_f32x4_nearest(offset), + Operator::F32x4Abs => self.visit_f32x4_abs(offset), + Operator::F32x4Neg => self.visit_f32x4_neg(offset), + Operator::F32x4Sqrt => self.visit_f32x4_sqrt(offset), + Operator::F32x4Add => self.visit_f32x4_add(offset), + Operator::F32x4Sub => self.visit_f32x4_sub(offset), + Operator::F32x4Mul => self.visit_f32x4_mul(offset), + Operator::F32x4Div => self.visit_f32x4_div(offset), + Operator::F32x4Min => self.visit_f32x4_min(offset), + Operator::F32x4Max => self.visit_f32x4_max(offset), + Operator::F32x4PMin => self.visit_f32x4_p_min(offset), + Operator::F32x4PMax => self.visit_f32x4_p_max(offset), + Operator::F64x2Ceil => self.visit_f64x2_ceil(offset), + Operator::F64x2Floor => self.visit_f64x2_floor(offset), + Operator::F64x2Trunc => self.visit_f64x2_trunc(offset), + Operator::F64x2Nearest => self.visit_f64x2_nearest(offset), + Operator::F64x2Abs => self.visit_f64x2_abs(offset), + Operator::F64x2Neg => self.visit_f64x2_neg(offset), + Operator::F64x2Sqrt => self.visit_f64x2_sqrt(offset), + Operator::F64x2Add => self.visit_f64x2_add(offset), + Operator::F64x2Sub => self.visit_f64x2_sub(offset), + Operator::F64x2Mul => self.visit_f64x2_mul(offset), + Operator::F64x2Div => self.visit_f64x2_div(offset), + Operator::F64x2Min => self.visit_f64x2_min(offset), + Operator::F64x2Max => self.visit_f64x2_max(offset), + Operator::F64x2PMin => self.visit_f64x2_p_min(offset), + Operator::F64x2PMax => self.visit_f64x2_p_max(offset), + Operator::I32x4TruncSatF32x4S => self.visit_i32x4_trunc_sat_f32x4_s(offset), + Operator::I32x4TruncSatF32x4U => self.visit_i32x4_trunc_sat_f32x4_u(offset), + Operator::F32x4ConvertI32x4S => self.visit_f32x4_convert_i32x4_s(offset), + Operator::F32x4ConvertI32x4U => self.visit_f32x4_convert_i32x4_u(offset), + Operator::I32x4TruncSatF64x2SZero => self.visit_i32x4_trunc_sat_f64x2_s_zero(offset), + Operator::I32x4TruncSatF64x2UZero => self.visit_i32x4_trunc_sat_f64x2_u_zero(offset), + Operator::F64x2ConvertLowI32x4S => self.visit_f64x2_convert_low_i32x4_s(offset), + Operator::F64x2ConvertLowI32x4U => self.visit_f64x2_convert_low_i32x4_u(offset), + Operator::F32x4DemoteF64x2Zero => self.visit_f32x4_demote_f64x2_zero(offset), + Operator::F64x2PromoteLowF32x4 => self.visit_f64x2_promote_low_f32x4(offset), + Operator::I8x16RelaxedSwizzle => self.visit_i8x16_relaxed_swizzle(offset), + Operator::I32x4RelaxedTruncSatF32x4S => self.visit_i32x4_relaxed_trunc_sat_f32x4_s(offset), + Operator::I32x4RelaxedTruncSatF32x4U => self.visit_i32x4_relaxed_trunc_sat_f32x4_u(offset), + Operator::I32x4RelaxedTruncSatF64x2SZero => self.visit_i32x4_relaxed_trunc_sat_f64x2_s_zero(offset), + Operator::I32x4RelaxedTruncSatF64x2UZero => self.visit_i32x4_relaxed_trunc_sat_f64x2_u_zero(offset), + Operator::F32x4Fma => self.visit_f32x4_fma(offset), + Operator::F32x4Fms => self.visit_f32x4_fms(offset), + Operator::F64x2Fma => self.visit_f64x2_fma(offset), + Operator::F64x2Fms => self.visit_f64x2_fms(offset), + Operator::I8x16LaneSelect => self.visit_i8x16_lane_select(offset), + Operator::I16x8LaneSelect => self.visit_i16x8_lane_select(offset), + Operator::I32x4LaneSelect => self.visit_i32x4_lane_select(offset), + Operator::I64x2LaneSelect => self.visit_i64x2_lane_select(offset), + Operator::F32x4RelaxedMin => self.visit_f32x4_relaxed_min(offset), + Operator::F32x4RelaxedMax => self.visit_f32x4_relaxed_max(offset), + Operator::F64x2RelaxedMin => self.visit_f64x2_relaxed_min(offset), + Operator::F64x2RelaxedMax => self.visit_f64x2_relaxed_max(offset), + + Operator::Rdpkru => self.visit_memory_read_pkru(offset), + Operator::Wrpkru => self.visit_memory_write_pkru(offset), + } + } + + fn visit_nop(&mut self, offset: usize) -> Self::Output; + fn visit_unreachable(&mut self, offset: usize) -> Self::Output; + fn visit_block(&mut self, offset: usize, ty: BlockType) -> Self::Output; + fn visit_loop(&mut self, offset: usize, ty: BlockType) -> Self::Output; + fn visit_if(&mut self, offset: usize, ty: BlockType) -> Self::Output; + fn visit_else(&mut self, offset: usize) -> Self::Output; + fn visit_try(&mut self, offset: usize, ty: BlockType) -> Self::Output; + fn visit_catch(&mut self, offset: usize, index: u32) -> Self::Output; + fn visit_throw(&mut self, offset: usize, index: u32) -> Self::Output; + fn visit_rethrow(&mut self, offset: usize, relative_depth: u32) -> Self::Output; + fn visit_delegate(&mut self, offset: usize, relative_depth: u32) -> Self::Output; + fn visit_catch_all(&mut self, offset: usize) -> Self::Output; + fn visit_end(&mut self, offset: usize) -> Self::Output; + fn visit_br(&mut self, offset: usize, relative_depth: u32) -> Self::Output; + fn visit_br_if(&mut self, offset: usize, relative_depth: u32) -> Self::Output; + fn visit_br_table(&mut self, offset: usize, table: &BrTable<'a>) -> Self::Output; + fn visit_return(&mut self, offset: usize) -> Self::Output; + fn visit_call(&mut self, offset: usize, function_index: u32) -> Self::Output; + fn visit_return_call(&mut self, offset: usize, function_index: u32) -> Self::Output; + fn visit_call_indirect( + &mut self, + offset: usize, + index: u32, + table_index: u32, + table_byte: u8, + ) -> Self::Output; + fn visit_return_call_indirect( + &mut self, + offset: usize, + index: u32, + table_index: u32, + ) -> Self::Output; + fn visit_drop(&mut self, offset: usize) -> Self::Output; + fn visit_select(&mut self, offset: usize) -> Self::Output; + fn visit_typed_select(&mut self, offset: usize, ty: ValType) -> Self::Output; + fn visit_local_get(&mut self, offset: usize, local_index: u32) -> Self::Output; + fn visit_local_set(&mut self, offset: usize, local_index: u32) -> Self::Output; + fn visit_local_tee(&mut self, offset: usize, local_index: u32) -> Self::Output; + fn visit_global_get(&mut self, offset: usize, global_index: u32) -> Self::Output; + fn visit_global_set(&mut self, offset: usize, global_index: u32) -> Self::Output; + fn visit_i32_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_f32_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_f64_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_load8_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_load8_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_load16_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_load16_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_load8_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_load8_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_load16_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_load16_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_load32_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_load32_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_f32_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_f64_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_store8(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_store16(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_store8(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_store16(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_store32(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_memory_size(&mut self, offset: usize, mem: u32, mem_byte: u8) -> Self::Output; + fn visit_memory_grow(&mut self, offset: usize, mem: u32, mem_byte: u8) -> Self::Output; + fn visit_i32_const(&mut self, offset: usize, value: i32) -> Self::Output; + fn visit_i64_const(&mut self, offset: usize, value: i64) -> Self::Output; + fn visit_f32_const(&mut self, offset: usize, value: Ieee32) -> Self::Output; + fn visit_f64_const(&mut self, offset: usize, value: Ieee64) -> Self::Output; + fn visit_i32_eqz(&mut self, offset: usize) -> Self::Output; + fn visit_i32_eq(&mut self, offset: usize) -> Self::Output; + fn visit_i32_ne(&mut self, offset: usize) -> Self::Output; + fn visit_i32_lt_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32_lt_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32_gt_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32_gt_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32_le_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32_le_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32_ge_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32_ge_u(&mut self, offset: usize) -> Self::Output; + fn visit_i64_eqz(&mut self, offset: usize) -> Self::Output; + fn visit_i64_eq(&mut self, offset: usize) -> Self::Output; + fn visit_i64_ne(&mut self, offset: usize) -> Self::Output; + fn visit_i64_lt_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64_lt_u(&mut self, offset: usize) -> Self::Output; + fn visit_i64_gt_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64_gt_u(&mut self, offset: usize) -> Self::Output; + fn visit_i64_le_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64_le_u(&mut self, offset: usize) -> Self::Output; + fn visit_i64_ge_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64_ge_u(&mut self, offset: usize) -> Self::Output; + fn visit_f32_eq(&mut self, offset: usize) -> Self::Output; + fn visit_f32_ne(&mut self, offset: usize) -> Self::Output; + fn visit_f32_lt(&mut self, offset: usize) -> Self::Output; + fn visit_f32_gt(&mut self, offset: usize) -> Self::Output; + fn visit_f32_le(&mut self, offset: usize) -> Self::Output; + fn visit_f32_ge(&mut self, offset: usize) -> Self::Output; + fn visit_f64_eq(&mut self, offset: usize) -> Self::Output; + fn visit_f64_ne(&mut self, offset: usize) -> Self::Output; + fn visit_f64_lt(&mut self, offset: usize) -> Self::Output; + fn visit_f64_gt(&mut self, offset: usize) -> Self::Output; + fn visit_f64_le(&mut self, offset: usize) -> Self::Output; + fn visit_f64_ge(&mut self, offset: usize) -> Self::Output; + fn visit_i32_clz(&mut self, offset: usize) -> Self::Output; + fn visit_i32_ctz(&mut self, offset: usize) -> Self::Output; + fn visit_i32_popcnt(&mut self, offset: usize) -> Self::Output; + fn visit_i32_add(&mut self, offset: usize) -> Self::Output; + fn visit_i32_sub(&mut self, offset: usize) -> Self::Output; + fn visit_i32_mul(&mut self, offset: usize) -> Self::Output; + fn visit_i32_div_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32_div_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32_rem_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32_rem_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32_and(&mut self, offset: usize) -> Self::Output; + fn visit_i32_or(&mut self, offset: usize) -> Self::Output; + fn visit_i32_xor(&mut self, offset: usize) -> Self::Output; + fn visit_i32_shl(&mut self, offset: usize) -> Self::Output; + fn visit_i32_shr_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32_shr_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32_rotl(&mut self, offset: usize) -> Self::Output; + fn visit_i32_rotr(&mut self, offset: usize) -> Self::Output; + fn visit_i64_clz(&mut self, offset: usize) -> Self::Output; + fn visit_i64_ctz(&mut self, offset: usize) -> Self::Output; + fn visit_i64_popcnt(&mut self, offset: usize) -> Self::Output; + fn visit_i64_add(&mut self, offset: usize) -> Self::Output; + fn visit_i64_sub(&mut self, offset: usize) -> Self::Output; + fn visit_i64_mul(&mut self, offset: usize) -> Self::Output; + fn visit_i64_div_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64_div_u(&mut self, offset: usize) -> Self::Output; + fn visit_i64_rem_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64_rem_u(&mut self, offset: usize) -> Self::Output; + fn visit_i64_and(&mut self, offset: usize) -> Self::Output; + fn visit_i64_or(&mut self, offset: usize) -> Self::Output; + fn visit_i64_xor(&mut self, offset: usize) -> Self::Output; + fn visit_i64_shl(&mut self, offset: usize) -> Self::Output; + fn visit_i64_shr_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64_shr_u(&mut self, offset: usize) -> Self::Output; + fn visit_i64_rotl(&mut self, offset: usize) -> Self::Output; + fn visit_i64_rotr(&mut self, offset: usize) -> Self::Output; + fn visit_f32_abs(&mut self, offset: usize) -> Self::Output; + fn visit_f32_neg(&mut self, offset: usize) -> Self::Output; + fn visit_f32_ceil(&mut self, offset: usize) -> Self::Output; + fn visit_f32_floor(&mut self, offset: usize) -> Self::Output; + fn visit_f32_trunc(&mut self, offset: usize) -> Self::Output; + fn visit_f32_nearest(&mut self, offset: usize) -> Self::Output; + fn visit_f32_sqrt(&mut self, offset: usize) -> Self::Output; + fn visit_f32_add(&mut self, offset: usize) -> Self::Output; + fn visit_f32_sub(&mut self, offset: usize) -> Self::Output; + fn visit_f32_mul(&mut self, offset: usize) -> Self::Output; + fn visit_f32_div(&mut self, offset: usize) -> Self::Output; + fn visit_f32_min(&mut self, offset: usize) -> Self::Output; + fn visit_f32_max(&mut self, offset: usize) -> Self::Output; + fn visit_f32_copysign(&mut self, offset: usize) -> Self::Output; + fn visit_f64_abs(&mut self, offset: usize) -> Self::Output; + fn visit_f64_neg(&mut self, offset: usize) -> Self::Output; + fn visit_f64_ceil(&mut self, offset: usize) -> Self::Output; + fn visit_f64_floor(&mut self, offset: usize) -> Self::Output; + fn visit_f64_trunc(&mut self, offset: usize) -> Self::Output; + fn visit_f64_nearest(&mut self, offset: usize) -> Self::Output; + fn visit_f64_sqrt(&mut self, offset: usize) -> Self::Output; + fn visit_f64_add(&mut self, offset: usize) -> Self::Output; + fn visit_f64_sub(&mut self, offset: usize) -> Self::Output; + fn visit_f64_mul(&mut self, offset: usize) -> Self::Output; + fn visit_f64_div(&mut self, offset: usize) -> Self::Output; + fn visit_f64_min(&mut self, offset: usize) -> Self::Output; + fn visit_f64_max(&mut self, offset: usize) -> Self::Output; + fn visit_f64_copysign(&mut self, offset: usize) -> Self::Output; + fn visit_i32_wrap_i64(&mut self, offset: usize) -> Self::Output; + fn visit_i32_trunc_f32s(&mut self, offset: usize) -> Self::Output; + fn visit_i32_trunc_f32u(&mut self, offset: usize) -> Self::Output; + fn visit_i32_trunc_f64s(&mut self, offset: usize) -> Self::Output; + fn visit_i32_trunc_f64u(&mut self, offset: usize) -> Self::Output; + fn visit_i64_extend_i32s(&mut self, offset: usize) -> Self::Output; + fn visit_i64_extend_i32u(&mut self, offset: usize) -> Self::Output; + fn visit_i64_trunc_f32s(&mut self, offset: usize) -> Self::Output; + fn visit_i64_trunc_f32u(&mut self, offset: usize) -> Self::Output; + fn visit_i64_trunc_f64s(&mut self, offset: usize) -> Self::Output; + fn visit_i64_trunc_f64u(&mut self, offset: usize) -> Self::Output; + fn visit_f32_convert_i32s(&mut self, offset: usize) -> Self::Output; + fn visit_f32_convert_i32u(&mut self, offset: usize) -> Self::Output; + fn visit_f32_convert_i64s(&mut self, offset: usize) -> Self::Output; + fn visit_f32_convert_i64u(&mut self, offset: usize) -> Self::Output; + fn visit_f32_demote_f64(&mut self, offset: usize) -> Self::Output; + fn visit_f64_convert_i32s(&mut self, offset: usize) -> Self::Output; + fn visit_f64_convert_i32u(&mut self, offset: usize) -> Self::Output; + fn visit_f64_convert_i64s(&mut self, offset: usize) -> Self::Output; + fn visit_f64_convert_i64u(&mut self, offset: usize) -> Self::Output; + fn visit_f64_promote_f32(&mut self, offset: usize) -> Self::Output; + fn visit_i32_reinterpret_f32(&mut self, offset: usize) -> Self::Output; + fn visit_i64_reinterpret_f64(&mut self, offset: usize) -> Self::Output; + fn visit_f32_reinterpret_i32(&mut self, offset: usize) -> Self::Output; + fn visit_f64_reinterpret_i64(&mut self, offset: usize) -> Self::Output; + fn visit_i32_trunc_sat_f32s(&mut self, offset: usize) -> Self::Output; + fn visit_i32_trunc_sat_f32u(&mut self, offset: usize) -> Self::Output; + fn visit_i32_trunc_sat_f64s(&mut self, offset: usize) -> Self::Output; + fn visit_i32_trunc_sat_f64u(&mut self, offset: usize) -> Self::Output; + fn visit_i64_trunc_sat_f32s(&mut self, offset: usize) -> Self::Output; + fn visit_i64_trunc_sat_f32u(&mut self, offset: usize) -> Self::Output; + fn visit_i64_trunc_sat_f64s(&mut self, offset: usize) -> Self::Output; + fn visit_i64_trunc_sat_f64u(&mut self, offset: usize) -> Self::Output; + fn visit_i32_extend8_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32_extend16_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64_extend8_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64_extend16_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64_extend32_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32_atomic_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_atomic_load16_u(&mut self, offset: usize, memarg: MemoryImmediate) + -> Self::Output; + fn visit_i32_atomic_load8_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_atomic_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_atomic_load32_u(&mut self, offset: usize, memarg: MemoryImmediate) + -> Self::Output; + fn visit_i64_atomic_load16_u(&mut self, offset: usize, memarg: MemoryImmediate) + -> Self::Output; + fn visit_i64_atomic_load8_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_atomic_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_atomic_store16(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_atomic_store8(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_atomic_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_atomic_store32(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_atomic_store16(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_atomic_store8(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_atomic_rmw_add(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_atomic_rmw_sub(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_atomic_rmw_and(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_atomic_rmw_or(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_atomic_rmw_xor(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i32_atomic_rmw16_add_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i32_atomic_rmw16_sub_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i32_atomic_rmw16_and_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i32_atomic_rmw16_or_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i32_atomic_rmw16_xor_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i32_atomic_rmw8_add_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i32_atomic_rmw8_sub_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i32_atomic_rmw8_and_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i32_atomic_rmw8_or_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i32_atomic_rmw8_xor_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw_add(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_atomic_rmw_sub(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_atomic_rmw_and(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_atomic_rmw_or(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_atomic_rmw_xor(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_i64_atomic_rmw32_add_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw32_sub_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw32_and_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw32_or_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw32_xor_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw16_add_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw16_sub_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw16_and_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw16_or_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw16_xor_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw8_add_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw8_sub_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw8_and_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw8_or_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw8_xor_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i32_atomic_rmw_xchg(&mut self, offset: usize, memarg: MemoryImmediate) + -> Self::Output; + fn visit_i32_atomic_rmw16_xchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i32_atomic_rmw8_xchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i32_atomic_rmw_cmpxchg( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i32_atomic_rmw16_cmpxchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i32_atomic_rmw8_cmpxchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw_xchg(&mut self, offset: usize, memarg: MemoryImmediate) + -> Self::Output; + fn visit_i64_atomic_rmw32_xchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw16_xchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw8_xchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw_cmpxchg( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw32_cmpxchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw16_cmpxchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_i64_atomic_rmw8_cmpxchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_memory_atomic_notify( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_memory_atomic_wait32( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_memory_atomic_wait64( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output; + fn visit_atomic_fence(&mut self, offset: usize, flags: u8) -> Self::Output; + fn visit_ref_null(&mut self, offset: usize, ty: ValType) -> Self::Output; + fn visit_ref_is_null(&mut self, offset: usize) -> Self::Output; + fn visit_ref_func(&mut self, offset: usize, function_index: u32) -> Self::Output; + fn visit_v128_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_v128_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_v128_const(&mut self, offset: usize, value: V128) -> Self::Output; + fn visit_i8x16_splat(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_splat(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_splat(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_splat(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_splat(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_splat(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_extract_lane_s(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output; + fn visit_i8x16_extract_lane_u(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output; + fn visit_i16x8_extract_lane_s(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output; + fn visit_i16x8_extract_lane_u(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output; + fn visit_i32x4_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output; + fn visit_i8x16_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output; + fn visit_i16x8_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output; + fn visit_i32x4_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output; + fn visit_i64x2_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output; + fn visit_i64x2_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output; + fn visit_f32x4_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output; + fn visit_f32x4_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output; + fn visit_f64x2_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output; + fn visit_f64x2_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output; + fn visit_f32x4_eq(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_ne(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_lt(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_gt(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_le(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_ge(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_eq(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_ne(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_lt(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_gt(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_le(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_ge(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_add(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_sub(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_mul(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_div(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_min(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_max(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_p_min(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_p_max(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_add(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_sub(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_mul(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_div(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_min(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_max(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_p_min(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_p_max(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_relaxed_min(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_relaxed_max(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_relaxed_min(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_relaxed_max(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_eq(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_ne(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_lt_s(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_lt_u(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_gt_s(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_gt_u(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_le_s(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_le_u(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_ge_s(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_ge_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_eq(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_ne(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_lt_s(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_lt_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_gt_s(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_gt_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_le_s(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_le_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_ge_s(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_ge_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_eq(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_ne(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_lt_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_lt_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_gt_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_gt_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_le_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_le_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_ge_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_ge_u(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_eq(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_ne(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_lt_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_gt_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_le_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_ge_s(&mut self, offset: usize) -> Self::Output; + fn visit_v128_and(&mut self, offset: usize) -> Self::Output; + fn visit_v128_and_not(&mut self, offset: usize) -> Self::Output; + fn visit_v128_or(&mut self, offset: usize) -> Self::Output; + fn visit_v128_xor(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_add(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_add_sat_s(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_add_sat_u(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_sub(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_sub_sat_s(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_sub_sat_u(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_min_s(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_min_u(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_max_s(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_max_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_add(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_add_sat_s(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_add_sat_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_sub(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_sub_sat_s(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_sub_sat_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_mul(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_min_s(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_min_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_max_s(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_max_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_add(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_sub(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_mul(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_min_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_min_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_max_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_max_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_dot_i16x8_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_add(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_sub(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_mul(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_rounding_average_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_rounding_average_u(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_narrow_i16x8_s(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_narrow_i16x8_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_narrow_i32x4_s(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_narrow_i32x4_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_ext_mul_low_i8x16_s(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_ext_mul_high_i8x16_s(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_ext_mul_low_i8x16_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_ext_mul_high_i8x16_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_ext_mul_low_i16x8_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_ext_mul_high_i16x8_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_ext_mul_low_i16x8_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_ext_mul_high_i16x8_u(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_ext_mul_low_i32x4_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_ext_mul_high_i32x4_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_ext_mul_low_i32x4_u(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_ext_mul_high_i32x4_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_q15_mulr_sat_s(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_ceil(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_floor(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_trunc(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_nearest(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_ceil(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_floor(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_trunc(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_nearest(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_abs(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_neg(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_sqrt(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_abs(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_neg(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_sqrt(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_demote_f64x2_zero(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_promote_low_f32x4(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_convert_low_i32x4_s(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_convert_low_i32x4_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_trunc_sat_f32x4_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_trunc_sat_f32x4_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_trunc_sat_f64x2_s_zero(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_trunc_sat_f64x2_u_zero(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_convert_i32x4_s(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_convert_i32x4_u(&mut self, offset: usize) -> Self::Output; + fn visit_v128_not(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_abs(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_neg(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_popcnt(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_abs(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_neg(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_abs(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_neg(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_abs(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_neg(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_extend_low_i8x16_s(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_extend_high_i8x16_s(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_extend_low_i8x16_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_extend_high_i8x16_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_extend_low_i16x8_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_extend_high_i16x8_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_extend_low_i16x8_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_extend_high_i16x8_u(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_extend_low_i32x4_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_extend_high_i32x4_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_extend_low_i32x4_u(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_extend_high_i32x4_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_ext_add_pairwise_i8x16_s(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_ext_add_pairwise_i8x16_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_ext_add_pairwise_i16x8_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_ext_add_pairwise_i16x8_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_relaxed_trunc_sat_f32x4_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_relaxed_trunc_sat_f32x4_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_relaxed_trunc_sat_f64x2_s_zero(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_relaxed_trunc_sat_f64x2_u_zero(&mut self, offset: usize) -> Self::Output; + fn visit_v128_bitselect(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_fma(&mut self, offset: usize) -> Self::Output; + fn visit_f32x4_fms(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_fma(&mut self, offset: usize) -> Self::Output; + fn visit_f64x2_fms(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_lane_select(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_lane_select(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_lane_select(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_lane_select(&mut self, offset: usize) -> Self::Output; + fn visit_v128_any_true(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_all_true(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_bitmask(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_all_true(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_bitmask(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_all_true(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_bitmask(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_all_true(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_bitmask(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_shl(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_shr_s(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_shr_u(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_shl(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_shr_s(&mut self, offset: usize) -> Self::Output; + fn visit_i16x8_shr_u(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_shl(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_shr_s(&mut self, offset: usize) -> Self::Output; + fn visit_i32x4_shr_u(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_shl(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_shr_s(&mut self, offset: usize) -> Self::Output; + fn visit_i64x2_shr_u(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_swizzle(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_relaxed_swizzle(&mut self, offset: usize) -> Self::Output; + fn visit_i8x16_shuffle(&mut self, offset: usize, lanes: [SIMDLaneIndex; 16]) -> Self::Output; + fn visit_v128_load8_splat(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_v128_load16_splat(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_v128_load32_splat(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_v128_load32_zero(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_v128_load64_splat(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_v128_load64_zero(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_v128_load8x8_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_v128_load8x8_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_v128_load16x4_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_v128_load16x4_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_v128_load32x2_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_v128_load32x2_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output; + fn visit_v128_load8_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output; + fn visit_v128_load16_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output; + fn visit_v128_load32_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output; + fn visit_v128_load64_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output; + fn visit_v128_store8_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output; + fn visit_v128_store16_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output; + fn visit_v128_store32_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output; + fn visit_v128_store64_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output; + fn visit_memory_init(&mut self, offset: usize, segment: u32, mem: u32) -> Self::Output; + fn visit_data_drop(&mut self, offset: usize, segment: u32) -> Self::Output; + fn visit_memory_copy(&mut self, offset: usize, dst: u32, src: u32) -> Self::Output; + fn visit_memory_fill(&mut self, offset: usize, mem: u32) -> Self::Output; + fn visit_table_init(&mut self, offset: usize, segment: u32, table: u32) -> Self::Output; + fn visit_elem_drop(&mut self, offset: usize, segment: u32) -> Self::Output; + fn visit_table_copy(&mut self, offset: usize, dst_table: u32, src_table: u32) -> Self::Output; + fn visit_table_get(&mut self, offset: usize, table: u32) -> Self::Output; + fn visit_table_set(&mut self, offset: usize, table: u32) -> Self::Output; + fn visit_table_grow(&mut self, offset: usize, table: u32) -> Self::Output; + fn visit_table_size(&mut self, offset: usize, table: u32) -> Self::Output; + fn visit_table_fill(&mut self, offset: usize, table: u32) -> Self::Output; + + fn visit_memory_read_pkru(&mut self, offset: usize) -> Self::Output; + fn visit_memory_write_pkru(&mut self, offset: usize) -> Self::Output; +} diff --git a/crates/wasmparser/src/readers/core/producers.rs b/crates/wasmparser/src/readers/core/producers.rs new file mode 100644 index 000000000..4999aa45b --- /dev/null +++ b/crates/wasmparser/src/readers/core/producers.rs @@ -0,0 +1,211 @@ +/* Copyright 2019 Mozilla Foundation + * + * 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. + */ + +use crate::{BinaryReader, Result, SectionIteratorLimited, SectionReader, SectionWithLimitedItems}; +use std::ops::Range; + +/// Represents a field value in the producers custom section. +#[derive(Debug, Copy, Clone)] +pub struct ProducersFieldValue<'a> { + /// The field name. + pub name: &'a str, + /// The field version. + pub version: &'a str, +} + +/// A reader for fields in the producers custom section. +pub struct ProducersFieldValuesReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> ProducersFieldValuesReader<'a> { + /// Gets the count of items in the reader. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Gets the original position of the reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + fn skip(reader: &mut BinaryReader, values_count: u32) -> Result<()> { + for _ in 0..values_count { + reader.skip_string()?; + reader.skip_string()?; + } + Ok(()) + } + + /// Reads a field from the reader. + pub fn read<'b>(&mut self) -> Result> + where + 'a: 'b, + { + let name = self.reader.read_string()?; + let version = self.reader.read_string()?; + Ok(ProducersFieldValue { name, version }) + } +} + +impl<'a> IntoIterator for ProducersFieldValuesReader<'a> { + type Item = Result>; + type IntoIter = ProducersFieldValuesIterator<'a>; + fn into_iter(self) -> Self::IntoIter { + let count = self.count; + ProducersFieldValuesIterator { + reader: self, + left: count, + err: false, + } + } +} + +/// An iterator over fields in the producers custom section. +pub struct ProducersFieldValuesIterator<'a> { + reader: ProducersFieldValuesReader<'a>, + left: u32, + err: bool, +} + +impl<'a> Iterator for ProducersFieldValuesIterator<'a> { + type Item = Result>; + fn next(&mut self) -> Option { + if self.err || self.left == 0 { + return None; + } + let result = self.reader.read(); + self.err = result.is_err(); + self.left -= 1; + Some(result) + } + fn size_hint(&self) -> (usize, Option) { + let count = self.reader.get_count() as usize; + (count, Some(count)) + } +} + +/// A field from the producers custom section. +#[derive(Debug, Copy, Clone)] +pub struct ProducersField<'a> { + /// The name of the field. + pub name: &'a str, + values_count: u32, + values_data: &'a [u8], + values_offset: usize, +} + +impl<'a> ProducersField<'a> { + /// Gets a reader of values for the field. + pub fn get_producer_field_values_reader<'b>(&self) -> Result> + where + 'a: 'b, + { + Ok(ProducersFieldValuesReader { + reader: BinaryReader::new_with_offset(self.values_data, self.values_offset), + count: self.values_count, + }) + } +} + +/// A reader for the producers custom section of a WebAssembly module. +pub struct ProducersSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> ProducersSectionReader<'a> { + /// Creates reader for the producers section. + /// + /// # Examples + /// ``` + /// # let data: &[u8] = &[0x01, 0x08, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, + /// # 0x02, 0x03, 0x77, 0x61, 0x74, 0x01, 0x31, 0x01, 0x43, 0x03, 0x39, 0x2e, 0x30]; + /// use wasmparser::{ProducersSectionReader, ProducersFieldValue, Result}; + /// let mut reader = ProducersSectionReader::new(data, 0).expect("producers reader"); + /// let field = reader.read().expect("producers field"); + /// assert!(field.name == "language"); + /// let mut values_reader = field.get_producer_field_values_reader().expect("values reader"); + /// let value = values_reader.into_iter().collect::>>().expect("values"); + /// assert!(value.len() == 2); + /// assert!(value[0].name == "wat" && value[0].version == "1"); + /// assert!(value[1].name == "C" && value[1].version == "9.0"); + /// ``` + pub fn new(data: &'a [u8], offset: usize) -> Result> { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(ProducersSectionReader { reader, count }) + } + + /// Gets the original position of the reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the reader. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads an item from the reader. + pub fn read<'b>(&mut self) -> Result> + where + 'a: 'b, + { + let name = self.reader.read_string()?; + let values_count = self.reader.read_var_u32()?; + let values_start = self.reader.position; + ProducersFieldValuesReader::skip(&mut self.reader, values_count)?; + let values_end = self.reader.position; + Ok(ProducersField { + name, + values_count, + values_data: &self.reader.buffer[values_start..values_end], + values_offset: self.reader.original_offset + values_start, + }) + } +} + +impl<'a> SectionReader for ProducersSectionReader<'a> { + type Item = ProducersField<'a>; + fn read(&mut self) -> Result { + ProducersSectionReader::read(self) + } + fn eof(&self) -> bool { + self.reader.eof() + } + fn original_position(&self) -> usize { + ProducersSectionReader::original_position(self) + } + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for ProducersSectionReader<'a> { + fn get_count(&self) -> u32 { + ProducersSectionReader::get_count(self) + } +} + +impl<'a> IntoIterator for ProducersSectionReader<'a> { + type Item = Result>; + type IntoIter = SectionIteratorLimited>; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/core/relocs.rs b/crates/wasmparser/src/readers/core/relocs.rs new file mode 100644 index 000000000..29a9e33fa --- /dev/null +++ b/crates/wasmparser/src/readers/core/relocs.rs @@ -0,0 +1,198 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{BinaryReader, Result, SectionIteratorLimited, SectionReader, SectionWithLimitedItems}; +use std::ops::Range; + +/// Represents a relocation type. +#[derive(Debug, Copy, Clone)] +#[allow(missing_docs)] +pub enum RelocType { + FunctionIndexLEB, + TableIndexSLEB, + TableIndexI32, + GlobalAddrLEB, + GlobalAddrSLEB, + GlobalAddrI32, + TypeIndexLEB, + GlobalIndexLEB, +} + +/// Represents known custom section kinds. +#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)] +pub enum CustomSectionKind { + /// The custom section is not known. + Unknown, + /// The name custom section. + Name, + /// The producers custom section. + Producers, + /// The source mapping URL custom section. + SourceMappingURL, + /// The reloc custom section. + Reloc, + /// The linking custom section. + Linking, +} + +/// Section code as defined [here]. +/// +/// [here]: https://webassembly.github.io/spec/core/binary/modules.html#sections +#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)] +pub enum SectionCode<'a> { + /// The custom section. + Custom { + /// The name of the custom section. + name: &'a str, + /// The kind of the custom section. + kind: CustomSectionKind, + }, + /// The type section. + Type, + /// The import section. + Import, + /// The function section. + Function, + /// The table section. + Table, + /// The memory section. + Memory, + /// The global section. + Global, + /// The export section. + Export, + /// The start section. + Start, + /// The element section. + Element, + /// The code section. + Code, + /// The data section. + Data, + /// The passive data count section. + DataCount, + /// The tag section. + Tag, +} + +/// Represents a relocation entry. +#[derive(Debug, Copy, Clone)] +pub struct Reloc { + /// The relocation type. + pub ty: RelocType, + /// The relocation offset. + pub offset: u32, + /// The relocation index. + pub index: u32, + /// The relocation addend. + pub addend: Option, +} + +/// A reader for the relocations custom section of a WebAssembly module. +pub struct RelocSectionReader<'a> { + reader: BinaryReader<'a>, + section_code: SectionCode<'a>, + count: u32, +} + +impl<'a> RelocSectionReader<'a> { + /// Constructs a new `RelocSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result> { + let mut reader = BinaryReader::new_with_offset(data, offset); + + let section_id_position = reader.position; + let section_id = reader.read_u7()?; + let section_code = reader.read_section_code(section_id, section_id_position)?; + + let count = reader.read_var_u32()?; + Ok(RelocSectionReader { + reader, + section_code, + count, + }) + } + + /// Gets a count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Gets the section code from the section. + pub fn get_section_code<'b>(&self) -> SectionCode<'b> + where + 'a: 'b, + { + self.section_code + } + + /// Gets the original position of the reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Reads an item from the reader. + pub fn read(&mut self) -> Result { + let ty = self.reader.read_reloc_type()?; + let offset = self.reader.read_var_u32()?; + let index = self.reader.read_var_u32()?; + let addend = match ty { + RelocType::FunctionIndexLEB + | RelocType::TableIndexSLEB + | RelocType::TableIndexI32 + | RelocType::TypeIndexLEB + | RelocType::GlobalIndexLEB => None, + RelocType::GlobalAddrLEB | RelocType::GlobalAddrSLEB | RelocType::GlobalAddrI32 => { + Some(self.reader.read_var_u32()?) + } + }; + Ok(Reloc { + ty, + offset, + index, + addend, + }) + } +} + +impl<'a> SectionReader for RelocSectionReader<'a> { + type Item = Reloc; + fn read(&mut self) -> Result { + RelocSectionReader::read(self) + } + fn eof(&self) -> bool { + self.reader.eof() + } + fn original_position(&self) -> usize { + RelocSectionReader::original_position(self) + } + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for RelocSectionReader<'a> { + fn get_count(&self) -> u32 { + RelocSectionReader::get_count(self) + } +} + +impl<'a> IntoIterator for RelocSectionReader<'a> { + type Item = Result; + type IntoIter = SectionIteratorLimited>; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/core/tables.rs b/crates/wasmparser/src/readers/core/tables.rs new file mode 100644 index 000000000..3121b5fe9 --- /dev/null +++ b/crates/wasmparser/src/readers/core/tables.rs @@ -0,0 +1,93 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{ + BinaryReader, Result, SectionIteratorLimited, SectionReader, SectionWithLimitedItems, TableType, +}; +use std::ops::Range; + +/// A reader for the table section of a WebAssembly module. +#[derive(Clone)] +pub struct TableSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> TableSectionReader<'a> { + /// Constructs a new `TableSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result> { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(TableSectionReader { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the table section. + /// + /// # Examples + /// ``` + /// use wasmparser::TableSectionReader; + /// + /// # let data: &[u8] = &[0x01, 0x70, 0x01, 0x01, 0x01]; + /// let mut table_reader = TableSectionReader::new(data, 0).unwrap(); + /// for _ in 0..table_reader.get_count() { + /// let table = table_reader.read().expect("table"); + /// println!("Table: {:?}", table); + /// } + /// ``` + pub fn read(&mut self) -> Result { + self.reader.read_table_type() + } +} + +impl<'a> SectionReader for TableSectionReader<'a> { + type Item = TableType; + fn read(&mut self) -> Result { + TableSectionReader::read(self) + } + fn eof(&self) -> bool { + self.reader.eof() + } + fn original_position(&self) -> usize { + TableSectionReader::original_position(self) + } + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for TableSectionReader<'a> { + fn get_count(&self) -> u32 { + TableSectionReader::get_count(self) + } +} + +impl<'a> IntoIterator for TableSectionReader<'a> { + type Item = Result; + type IntoIter = SectionIteratorLimited>; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/core/tags.rs b/crates/wasmparser/src/readers/core/tags.rs new file mode 100644 index 000000000..fd4077979 --- /dev/null +++ b/crates/wasmparser/src/readers/core/tags.rs @@ -0,0 +1,92 @@ +/* Copyright 2020 Mozilla Foundation + * + * 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. + */ + +use crate::{ + BinaryReader, Result, SectionIteratorLimited, SectionReader, SectionWithLimitedItems, TagType, +}; +use std::ops::Range; + +/// A reader for the tags section of a WebAssembly module. +#[derive(Clone)] +pub struct TagSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> TagSectionReader<'a> { + /// Constructs a new `TagSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result> { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(TagSectionReader { reader, count }) + } + + /// Gets the original position of the section reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets the count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the tag section. + /// + /// # Examples + /// ``` + /// use wasmparser::TagSectionReader; + /// # let data: &[u8] = &[0x01, 0x00, 0x01]; + /// let mut reader = TagSectionReader::new(data, 0).unwrap(); + /// for _ in 0..reader.get_count() { + /// let ty = reader.read().expect("tag type"); + /// println!("Tag type: {:?}", ty); + /// } + /// ``` + pub fn read(&mut self) -> Result { + self.reader.read_tag_type() + } +} + +impl<'a> SectionReader for TagSectionReader<'a> { + type Item = TagType; + fn read(&mut self) -> Result { + TagSectionReader::read(self) + } + fn eof(&self) -> bool { + self.reader.eof() + } + fn original_position(&self) -> usize { + TagSectionReader::original_position(self) + } + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for TagSectionReader<'a> { + fn get_count(&self) -> u32 { + TagSectionReader::get_count(self) + } +} + +impl<'a> IntoIterator for TagSectionReader<'a> { + type Item = Result; + type IntoIter = SectionIteratorLimited>; + + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/readers/core/types.rs b/crates/wasmparser/src/readers/core/types.rs new file mode 100644 index 000000000..c5da30ff5 --- /dev/null +++ b/crates/wasmparser/src/readers/core/types.rs @@ -0,0 +1,230 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{BinaryReader, Result, SectionIteratorLimited, SectionReader, SectionWithLimitedItems}; +use std::ops::Range; + +/// Represents the types of values in a WebAssembly module. +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum ValType { + /// The value type is i32. + I32, + /// The value type is i64. + I64, + /// The value type is f32. + F32, + /// The value type is f64. + F64, + /// The value type is v128. + V128, + /// The value type is a function reference. + FuncRef, + /// The value type is an extern reference. + ExternRef, +} + +impl ValType { + /// Returns whether this value type is a "reference type". + /// + /// Only reference types are allowed in tables, for example, and with some + /// instructions. Current reference types include `funcref` and `externref`. + pub fn is_reference_type(&self) -> bool { + match self { + ValType::FuncRef | ValType::ExternRef => true, + _ => false, + } + } +} + +/// Represents a type in a WebAssembly module. +#[derive(Debug, Clone)] +pub enum Type { + /// The type is for a function. + Func(FuncType), +} + +/// Represents a type of a function in a WebAssembly module. +#[derive(Debug, Clone, Eq, PartialEq, Hash)] +pub struct FuncType { + /// The function parameter types. + pub params: Box<[ValType]>, + /// The function result types. + pub returns: Box<[ValType]>, +} + +/// Represents a table's type. +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub struct TableType { + /// The table's element type. + pub element_type: ValType, + /// Initial size of this table, in elements. + pub initial: u32, + /// Optional maximum size of the table, in elements. + pub maximum: Option, +} + +/// Represents a memory's type. +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub struct MemoryType { + /// Whether or not this is a 64-bit memory, using i64 as an index. If this + /// is false it's a 32-bit memory using i32 as an index. + /// + /// This is part of the memory64 proposal in WebAssembly. + pub memory64: bool, + + /// Whether or not this is a "shared" memory, indicating that it should be + /// send-able across threads and the `maximum` field is always present for + /// valid types. + /// + /// This is part of the threads proposal in WebAssembly. + pub shared: bool, + + /// Initial size of this memory, in wasm pages. + /// + /// For 32-bit memories (when `memory64` is `false`) this is guaranteed to + /// be at most `u32::MAX` for valid types. + pub initial: u64, + + /// Optional maximum size of this memory, in wasm pages. + /// + /// For 32-bit memories (when `memory64` is `false`) this is guaranteed to + /// be at most `u32::MAX` for valid types. This field is always present for + /// valid wasm memories when `shared` is `true`. + pub maximum: Option, +} + +impl MemoryType { + /// Gets the index type for the memory. + pub fn index_type(&self) -> ValType { + if self.memory64 { + ValType::I64 + } else { + ValType::I32 + } + } +} + +/// Represents a global's type. +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub struct GlobalType { + /// The global's type. + pub content_type: ValType, + /// Whether or not the global is mutable. + pub mutable: bool, +} + +/// Represents a tag kind. +#[derive(Clone, Copy, Debug)] +pub enum TagKind { + /// The tag is an exception type. + Exception, +} + +/// A tag's type. +#[derive(Clone, Copy, Debug)] +pub struct TagType { + /// The kind of tag + pub kind: TagKind, + /// The function type this tag uses. + pub func_type_idx: u32, +} + +/// A reader for the type section of a WebAssembly module. +#[derive(Clone)] +pub struct TypeSectionReader<'a> { + reader: BinaryReader<'a>, + count: u32, +} + +impl<'a> TypeSectionReader<'a> { + /// Constructs a new `TypeSectionReader` for the given data and offset. + pub fn new(data: &'a [u8], offset: usize) -> Result { + let mut reader = BinaryReader::new_with_offset(data, offset); + let count = reader.read_var_u32()?; + Ok(Self { reader, count }) + } + + /// Gets the original position of the reader. + pub fn original_position(&self) -> usize { + self.reader.original_position() + } + + /// Gets a count of items in the section. + pub fn get_count(&self) -> u32 { + self.count + } + + /// Reads content of the type section. + /// + /// # Examples + /// ``` + /// use wasmparser::TypeSectionReader; + /// let data: &[u8] = &[0x01, 0x60, 0x00, 0x00]; + /// let mut reader = TypeSectionReader::new(data, 0).unwrap(); + /// for _ in 0..reader.get_count() { + /// let ty = reader.read().expect("type"); + /// println!("Type {:?}", ty); + /// } + /// ``` + pub fn read(&mut self) -> Result { + self.reader.read_type() + } +} + +impl<'a> SectionReader for TypeSectionReader<'a> { + type Item = Type; + + fn read(&mut self) -> Result { + Self::read(self) + } + + fn eof(&self) -> bool { + self.reader.eof() + } + + fn original_position(&self) -> usize { + Self::original_position(self) + } + + fn range(&self) -> Range { + self.reader.range() + } +} + +impl<'a> SectionWithLimitedItems for TypeSectionReader<'a> { + fn get_count(&self) -> u32 { + Self::get_count(self) + } +} + +impl<'a> IntoIterator for TypeSectionReader<'a> { + type Item = Result; + type IntoIter = SectionIteratorLimited; + + /// Implements iterator over the type section. + /// + /// # Examples + /// ``` + /// use wasmparser::TypeSectionReader; + /// # let data: &[u8] = &[0x01, 0x60, 0x00, 0x00]; + /// let mut reader = TypeSectionReader::new(data, 0).unwrap(); + /// for ty in reader { + /// println!("Type {:?}", ty.expect("type")); + /// } + /// ``` + fn into_iter(self) -> Self::IntoIter { + SectionIteratorLimited::new(self) + } +} diff --git a/crates/wasmparser/src/resources.rs b/crates/wasmparser/src/resources.rs new file mode 100644 index 000000000..a15c755af --- /dev/null +++ b/crates/wasmparser/src/resources.rs @@ -0,0 +1,327 @@ +/* Copyright 2019 Mozilla Foundation + * + * 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. + */ + +use crate::{FuncType, GlobalType, MemoryType, TableType, ValType}; +use std::ops::Range; + +/// Types that qualify as Wasm function types for validation purposes. +pub trait WasmFuncType { + /// Returns the number of input types. + fn len_inputs(&self) -> usize; + /// Returns the number of output types. + fn len_outputs(&self) -> usize; + /// Returns the type at given index if any. + /// + /// # Note + /// + /// The returned type may be wrapped by the user crate and thus + /// the actually returned type only has to be comparable to a Wasm type. + fn input_at(&self, at: u32) -> Option; + /// Returns the type at given index if any. + /// + /// # Note + /// + /// The returned type may be wrapped by the user crate and thus + /// the actually returned type only has to be comparable to a Wasm type. + fn output_at(&self, at: u32) -> Option; + + /// Returns the list of inputs as an iterator. + fn inputs(&self) -> WasmFuncTypeInputs<'_, Self> + where + Self: Sized, + { + WasmFuncTypeInputs { + func_type: self, + range: 0..self.len_inputs() as u32, + } + } + + /// Returns the list of outputs as an iterator. + fn outputs(&self) -> WasmFuncTypeOutputs<'_, Self> + where + Self: Sized, + { + WasmFuncTypeOutputs { + func_type: self, + range: 0..self.len_outputs() as u32, + } + } +} + +impl WasmFuncType for &'_ T +where + T: ?Sized + WasmFuncType, +{ + fn len_inputs(&self) -> usize { + T::len_inputs(self) + } + fn len_outputs(&self) -> usize { + T::len_outputs(self) + } + fn input_at(&self, at: u32) -> Option { + T::input_at(self, at) + } + fn output_at(&self, at: u32) -> Option { + T::output_at(self, at) + } +} + +/// Iterator over the inputs of a Wasm function type. +pub struct WasmFuncTypeInputs<'a, T> { + /// The iterated-over function type. + func_type: &'a T, + /// The range we're iterating over. + range: Range, +} + +impl Iterator for WasmFuncTypeInputs<'_, T> +where + T: WasmFuncType, +{ + type Item = crate::ValType; + + fn next(&mut self) -> Option { + self.range + .next() + .map(|i| self.func_type.input_at(i).unwrap()) + } + + fn size_hint(&self) -> (usize, Option) { + self.range.size_hint() + } +} + +impl DoubleEndedIterator for WasmFuncTypeInputs<'_, T> +where + T: WasmFuncType, +{ + fn next_back(&mut self) -> Option { + self.range + .next_back() + .map(|i| self.func_type.input_at(i).unwrap()) + } +} + +impl ExactSizeIterator for WasmFuncTypeInputs<'_, T> +where + T: WasmFuncType, +{ + fn len(&self) -> usize { + self.range.len() + } +} + +impl<'a, T> Clone for WasmFuncTypeInputs<'a, T> { + fn clone(&self) -> WasmFuncTypeInputs<'a, T> { + WasmFuncTypeInputs { + func_type: self.func_type, + range: self.range.clone(), + } + } +} + +/// Iterator over the outputs of a Wasm function type. +pub struct WasmFuncTypeOutputs<'a, T> { + /// The iterated-over function type. + func_type: &'a T, + /// The range we're iterating over. + range: Range, +} + +impl Iterator for WasmFuncTypeOutputs<'_, T> +where + T: WasmFuncType, +{ + type Item = crate::ValType; + + fn next(&mut self) -> Option { + self.range + .next() + .map(|i| self.func_type.output_at(i).unwrap()) + } + + fn size_hint(&self) -> (usize, Option) { + self.range.size_hint() + } +} + +impl DoubleEndedIterator for WasmFuncTypeOutputs<'_, T> +where + T: WasmFuncType, +{ + fn next_back(&mut self) -> Option { + self.range + .next_back() + .map(|i| self.func_type.output_at(i).unwrap()) + } +} + +impl ExactSizeIterator for WasmFuncTypeOutputs<'_, T> +where + T: WasmFuncType, +{ + fn len(&self) -> usize { + self.range.len() + } +} + +impl<'a, T> Clone for WasmFuncTypeOutputs<'a, T> { + fn clone(&self) -> WasmFuncTypeOutputs<'a, T> { + WasmFuncTypeOutputs { + func_type: self.func_type, + range: self.range.clone(), + } + } +} + +/// Types that qualify as Wasm validation database. +/// +/// # Note +/// +/// The `wasmparser` crate provides a builtin validation framework but allows +/// users of this crate to also feed the parsed Wasm into their own data +/// structure while parsing and also validate at the same time without +/// the need of an additional parsing or validation step or copying data around. +pub trait WasmModuleResources { + /// The function type used for validation. + type FuncType: WasmFuncType; + + /// Returns the table at given index if any. + fn table_at(&self, at: u32) -> Option; + /// Returns the linear memory at given index. + fn memory_at(&self, at: u32) -> Option; + /// Returns the tag at given index. + fn tag_at(&self, at: u32) -> Option<&Self::FuncType>; + /// Returns the global variable at given index. + fn global_at(&self, at: u32) -> Option; + /// Returns the `FuncType` associated with the given type index. + fn func_type_at(&self, type_idx: u32) -> Option<&Self::FuncType>; + /// Returns the `FuncType` associated with the given function index. + fn type_of_function(&self, func_idx: u32) -> Option<&Self::FuncType>; + /// Returns the element type at the given index. + fn element_type_at(&self, at: u32) -> Option; + + /// Returns the number of elements. + fn element_count(&self) -> u32; + /// Returns the number of bytes in the Wasm data section. + fn data_count(&self) -> Option; + /// Returns whether the function index is referenced in the module anywhere + /// outside of the start/function sections. + fn is_function_referenced(&self, idx: u32) -> bool; +} + +impl WasmModuleResources for &'_ T +where + T: ?Sized + WasmModuleResources, +{ + type FuncType = T::FuncType; + + fn table_at(&self, at: u32) -> Option { + T::table_at(self, at) + } + fn memory_at(&self, at: u32) -> Option { + T::memory_at(self, at) + } + fn tag_at(&self, at: u32) -> Option<&Self::FuncType> { + T::tag_at(self, at) + } + fn global_at(&self, at: u32) -> Option { + T::global_at(self, at) + } + fn func_type_at(&self, at: u32) -> Option<&Self::FuncType> { + T::func_type_at(self, at) + } + fn type_of_function(&self, func_idx: u32) -> Option<&Self::FuncType> { + T::type_of_function(self, func_idx) + } + fn element_type_at(&self, at: u32) -> Option { + T::element_type_at(self, at) + } + + fn element_count(&self) -> u32 { + T::element_count(self) + } + fn data_count(&self) -> Option { + T::data_count(self) + } + fn is_function_referenced(&self, idx: u32) -> bool { + T::is_function_referenced(self, idx) + } +} + +impl WasmModuleResources for std::sync::Arc +where + T: WasmModuleResources, +{ + type FuncType = T::FuncType; + + fn table_at(&self, at: u32) -> Option { + T::table_at(self, at) + } + + fn memory_at(&self, at: u32) -> Option { + T::memory_at(self, at) + } + + fn tag_at(&self, at: u32) -> Option<&Self::FuncType> { + T::tag_at(self, at) + } + + fn global_at(&self, at: u32) -> Option { + T::global_at(self, at) + } + + fn func_type_at(&self, type_idx: u32) -> Option<&Self::FuncType> { + T::func_type_at(self, type_idx) + } + + fn type_of_function(&self, func_idx: u32) -> Option<&Self::FuncType> { + T::type_of_function(self, func_idx) + } + + fn element_type_at(&self, at: u32) -> Option { + T::element_type_at(self, at) + } + + fn element_count(&self) -> u32 { + T::element_count(self) + } + + fn data_count(&self) -> Option { + T::data_count(self) + } + + fn is_function_referenced(&self, idx: u32) -> bool { + T::is_function_referenced(self, idx) + } +} + +impl WasmFuncType for FuncType { + fn len_inputs(&self) -> usize { + self.params.len() + } + + fn len_outputs(&self) -> usize { + self.returns.len() + } + + fn input_at(&self, at: u32) -> Option { + self.params.get(at as usize).copied() + } + + fn output_at(&self, at: u32) -> Option { + self.returns.get(at as usize).copied() + } +} diff --git a/crates/wasmparser/src/validator.rs b/crates/wasmparser/src/validator.rs new file mode 100644 index 000000000..1b6a1176e --- /dev/null +++ b/crates/wasmparser/src/validator.rs @@ -0,0 +1,1455 @@ +/* Copyright 2018 Mozilla Foundation + * + * 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. + */ + +use crate::{ + limits::*, BinaryReaderError, Encoding, FunctionBody, Parser, Payload, Result, SectionReader, + SectionWithLimitedItems, ValType, WASM_COMPONENT_VERSION, WASM_MODULE_VERSION, +}; +use std::mem; +use std::ops::Range; +use std::sync::Arc; + +/// Test whether the given buffer contains a valid WebAssembly module or component, +/// analogous to [`WebAssembly.validate`][js] in the JS API. +/// +/// This functions requires the bytes to validate are entirely resident in memory. +/// Additionally this validates the given bytes with the default set of WebAssembly +/// features implemented by `wasmparser`. +/// +/// For more fine-tuned control over validation it's recommended to review the +/// documentation of [`Validator`]. +/// +/// Upon success, the type information for the top-level module or component will +/// be returned. +/// +/// [js]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/validate +pub fn validate(bytes: &[u8]) -> Result { + Validator::new().validate_all(bytes) +} + +#[test] +fn test_validate() { + assert!(validate(&[0x0, 0x61, 0x73, 0x6d, 0x1, 0x0, 0x0, 0x0]).is_ok()); + assert!(validate(&[0x0, 0x61, 0x73, 0x6d, 0x2, 0x0, 0x0, 0x0]).is_err()); +} + +mod component; +mod core; +mod func; +mod operators; +pub mod types; + +use self::component::*; +pub use self::core::ValidatorResources; +use self::core::*; +use self::types::{TypeList, Types, TypesRef}; +pub use func::FuncValidator; + +fn check_max(cur_len: usize, amt_added: u32, max: usize, desc: &str, offset: usize) -> Result<()> { + if max + .checked_sub(cur_len) + .and_then(|amt| amt.checked_sub(amt_added as usize)) + .is_none() + { + if max == 1 { + return Err(BinaryReaderError::new(format!("multiple {}", desc), offset)); + } + + return Err(BinaryReaderError::new( + format!("{} count exceeds limit of {}", desc, max), + offset, + )); + } + + Ok(()) +} + +fn combine_type_sizes(a: usize, b: usize, offset: usize) -> Result { + match a.checked_add(b) { + Some(sum) if sum < MAX_WASM_TYPE_SIZE => Ok(sum), + _ => Err(BinaryReaderError::new( + format!("effective type size exceeds the limit of {MAX_WASM_TYPE_SIZE}"), + offset, + )), + } +} + +/// Validator for a WebAssembly binary module or component. +/// +/// This structure encapsulates state necessary to validate a WebAssembly +/// binary. This implements validation as defined by the [core +/// specification][core]. A `Validator` is designed, like +/// [`Parser`], to accept incremental input over time. +/// Additionally a `Validator` is also designed for parallel validation of +/// functions as they are received. +/// +/// It's expected that you'll be using a [`Parser`] in tandem with a +/// `Validator`. As each [`Payload`](crate::Payload) is received from a +/// [`Parser`] you'll pass it into a `Validator` to test the validity of the +/// payload. Note that all payloads received from a [`Parser`] are expected to +/// be passed to a [`Validator`]. For example if you receive +/// [`Payload::TypeSection`](crate::Payload) you'll call +/// [`Validator::type_section`] to validate this. +/// +/// The design of [`Validator`] is intended that you'll interleave, in your own +/// application's processing, calls to validation. Each variant, after it's +/// received, will be validated and then your application would proceed as +/// usual. At all times, however, you'll have access to the [`Validator`] and +/// the validation context up to that point. This enables applications to check +/// the types of functions and learn how many globals there are, for example. +/// +/// [core]: https://webassembly.github.io/spec/core/valid/index.html +#[derive(Default)] +pub struct Validator { + /// The current state of the validator. + state: State, + + /// The global type space used by the validator and any sub-validators. + types: TypeList, + + /// The module state when parsing a WebAssembly module. + module: Option, + + /// With the component model enabled, this stores the pushed component states. + /// The top of the stack is the current component state. + components: Vec, + + /// Enabled WebAssembly feature flags, dictating what's valid and what + /// isn't. + features: WasmFeatures, +} + +#[derive(Debug, Clone, Copy, Eq, PartialEq)] +enum State { + /// A header has not yet been parsed. + /// + /// The value is the expected encoding for the header. + Unparsed(Option), + /// A module header has been parsed. + /// + /// The associated module state is available via [`Validator::module`]. + Module, + /// A component header has been parsed. + /// + /// The associated component state exists at the top of the + /// validator's [`Validator::components`] stack. + Component, + /// The parse has completed and no more data is expected. + End, +} + +impl State { + fn ensure_parsable(&self, offset: usize) -> Result<()> { + match self { + Self::Module | Self::Component => Ok(()), + Self::Unparsed(_) => Err(BinaryReaderError::new( + "unexpected section before header was parsed", + offset, + )), + Self::End => Err(BinaryReaderError::new( + "unexpected section after parsing has completed", + offset, + )), + } + } + + fn ensure_module(&self, section: &str, offset: usize) -> Result<()> { + self.ensure_parsable(offset)?; + + match self { + Self::Module => Ok(()), + Self::Component => Err(BinaryReaderError::new( + format!( + "unexpected module {} section while parsing a component", + section + ), + offset, + )), + _ => unreachable!(), + } + } + + fn ensure_component(&self, section: &str, offset: usize) -> Result<()> { + self.ensure_parsable(offset)?; + + match self { + Self::Component => Ok(()), + Self::Module => Err(BinaryReaderError::new( + format!( + "unexpected component {} section while parsing a module", + section + ), + offset, + )), + _ => unreachable!(), + } + } +} + +impl Default for State { + fn default() -> Self { + Self::Unparsed(None) + } +} + +/// Flags for features that are enabled for validation. +#[derive(Hash, Debug, Copy, Clone)] +pub struct WasmFeatures { + /// The WebAssembly `mutable-global` proposal (enabled by default) + pub mutable_global: bool, + /// The WebAssembly `nontrapping-float-to-int-conversions` proposal (enabled by default) + pub saturating_float_to_int: bool, + /// The WebAssembly `sign-extension-ops` proposal (enabled by default) + pub sign_extension: bool, + /// The WebAssembly reference types proposal (enabled by default) + pub reference_types: bool, + /// The WebAssembly multi-value proposal (enabled by default) + pub multi_value: bool, + /// The WebAssembly bulk memory operations proposal (enabled by default) + pub bulk_memory: bool, + /// The WebAssembly SIMD proposal + pub simd: bool, + /// The WebAssembly Relaxed SIMD proposal + pub relaxed_simd: bool, + /// The WebAssembly threads proposal + pub threads: bool, + /// The WebAssembly tail-call proposal + pub tail_call: bool, + /// Whether or not only deterministic instructions are allowed + pub deterministic_only: bool, + /// The WebAssembly multi memory proposal + pub multi_memory: bool, + /// The WebAssembly exception handling proposal + pub exceptions: bool, + /// The WebAssembly memory64 proposal + pub memory64: bool, + /// The WebAssembly extended_const proposal + pub extended_const: bool, + /// The WebAssembly component model proposal. + pub component_model: bool, +} + +impl WasmFeatures { + pub(crate) fn check_value_type(&self, ty: ValType) -> Result<(), &'static str> { + match ty { + ValType::I32 | ValType::I64 | ValType::F32 | ValType::F64 => Ok(()), + ValType::FuncRef | ValType::ExternRef => { + if self.reference_types { + Ok(()) + } else { + Err("reference types support is not enabled") + } + } + ValType::V128 => { + if self.simd { + Ok(()) + } else { + Err("SIMD support is not enabled") + } + } + } + } +} + +impl Default for WasmFeatures { + fn default() -> WasmFeatures { + WasmFeatures { + // off-by-default features + relaxed_simd: false, + threads: false, + tail_call: false, + multi_memory: false, + exceptions: false, + memory64: false, + extended_const: false, + component_model: false, + deterministic_only: cfg!(feature = "deterministic"), + + // on-by-default features + mutable_global: true, + saturating_float_to_int: true, + sign_extension: true, + bulk_memory: true, + multi_value: true, + reference_types: true, + simd: true, + } + } +} + +/// Possible return values from [`Validator::payload`]. +#[allow(clippy::large_enum_variant)] +pub enum ValidPayload<'a> { + /// The payload validated, no further action need be taken. + Ok, + /// The payload validated, but it started a nested module or component. + /// + /// This result indicates that the specified parser should be used instead + /// of the currently-used parser until this returned one ends. + Parser(Parser), + /// A function was found to be validate. + Func(FuncValidator, FunctionBody<'a>), + /// The end payload was validated and the types known to the validator + /// are provided. + End(Types), +} + +impl Validator { + /// Creates a new [`Validator`] ready to validate a WebAssembly module + /// or component. + /// + /// The new validator will receive payloads parsed from + /// [`Parser`], and expects the first payload received to be + /// the version header from the parser. + pub fn new() -> Validator { + Validator::default() + } + + /// Creates a new [`Validator`] which has the specified set of wasm + /// features activated for validation. + /// + /// This function is the same as [`Validator::new`] except it also allows + /// you to customize the active wasm features in use for validation. This + /// can allow enabling experimental proposals or also turning off + /// on-by-default wasm proposals. + pub fn new_with_features(features: WasmFeatures) -> Validator { + let mut ret = Validator::new(); + ret.features = features; + ret + } + + /// Returns the wasm features used for this validator. + pub fn features(&self) -> &WasmFeatures { + &self.features + } + + /// Validates an entire in-memory module or component with this validator. + /// + /// This function will internally create a [`Parser`] to parse the `bytes` + /// provided. The entire module or component specified by `bytes` will be + /// parsed and validated. + /// + /// Upon success, the type information for the top-level module or component + /// will be returned. + pub fn validate_all(&mut self, bytes: &[u8]) -> Result { + let mut functions_to_validate = Vec::new(); + let mut last_types = None; + for payload in Parser::new(0).parse_all(bytes) { + match self.payload(&payload?)? { + ValidPayload::Func(a, b) => { + functions_to_validate.push((a, b)); + } + ValidPayload::End(types) => { + // Only the last (top-level) type information will be returned + last_types = Some(types); + } + _ => {} + } + } + + for (mut validator, body) in functions_to_validate { + validator.validate(&body)?; + } + + Ok(last_types.unwrap()) + } + + /// Gets the types known by the validator so far within the + /// module/component `level` modules/components up from the + /// module/component currently being parsed. + /// + /// For instance, calling `validator.types(0)` will get the types of the + /// module/component currently being parsed, and `validator.types(1)` will + /// get the types of the component containing that module/component. + /// + /// Returns `None` if there is no module/component that many levels up. + pub fn types(&self, mut level: usize) -> Option { + if let Some(module) = &self.module { + if level == 0 { + return Some(TypesRef::from_module(&self.types, &module.module)); + } else { + level -= 1; + } + } + + self.components + .iter() + .nth_back(level) + .map(|component| TypesRef::from_component(&self.types, component)) + } + + /// Convenience function to validate a single [`Payload`]. + /// + /// This function is intended to be used as a convenience. It will + /// internally perform any validation necessary to validate the [`Payload`] + /// provided. The convenience part is that you're likely already going to + /// be matching on [`Payload`] in your application, at which point it's more + /// appropriate to call the individual methods on [`Validator`] per-variant + /// in [`Payload`], such as [`Validator::type_section`]. + /// + /// This function returns a [`ValidPayload`] variant on success, indicating + /// one of a few possible actions that need to be taken after a payload is + /// validated. For example function contents are not validated here, they're + /// returned through [`ValidPayload`] for validation by the caller. + pub fn payload<'a>(&mut self, payload: &Payload<'a>) -> Result> { + use crate::Payload::*; + match payload { + Version { + num, + encoding, + range, + } => self.version(*num, *encoding, range)?, + + // Module sections + TypeSection(s) => self.type_section(s)?, + ImportSection(s) => self.import_section(s)?, + FunctionSection(s) => self.function_section(s)?, + TableSection(s) => self.table_section(s)?, + MemorySection(s) => self.memory_section(s)?, + TagSection(s) => self.tag_section(s)?, + GlobalSection(s) => self.global_section(s)?, + ExportSection(s) => self.export_section(s)?, + StartSection { func, range } => self.start_section(*func, range)?, + ElementSection(s) => self.element_section(s)?, + DataCountSection { count, range } => self.data_count_section(*count, range)?, + CodeSectionStart { + count, + range, + size: _, + } => self.code_section_start(*count, range)?, + CodeSectionEntry(body) => { + let func_validator = self.code_section_entry(body)?; + return Ok(ValidPayload::Func(func_validator, *body)); + } + DataSection(s) => self.data_section(s)?, + + // Component sections + ModuleSection { parser, range, .. } => { + self.module_section(range)?; + return Ok(ValidPayload::Parser(parser.clone())); + } + InstanceSection(s) => self.instance_section(s)?, + AliasSection(s) => self.alias_section(s)?, + CoreTypeSection(s) => self.core_type_section(s)?, + ComponentSection { parser, range, .. } => { + self.component_section(range)?; + return Ok(ValidPayload::Parser(parser.clone())); + } + ComponentInstanceSection(s) => self.component_instance_section(s)?, + ComponentAliasSection(s) => self.component_alias_section(s)?, + ComponentTypeSection(s) => self.component_type_section(s)?, + ComponentCanonicalSection(s) => self.component_canonical_section(s)?, + ComponentStartSection(s) => self.component_start_section(s)?, + ComponentImportSection(s) => self.component_import_section(s)?, + ComponentExportSection(s) => self.component_export_section(s)?, + + End(offset) => return Ok(ValidPayload::End(self.end(*offset)?)), + + CustomSection { .. } => {} // no validation for custom sections + UnknownSection { id, range, .. } => self.unknown_section(*id, range)?, + } + Ok(ValidPayload::Ok) + } + + /// Validates [`Payload::Version`](crate::Payload). + pub fn version(&mut self, num: u32, encoding: Encoding, range: &Range) -> Result<()> { + match &self.state { + State::Unparsed(expected) => { + if let Some(expected) = expected { + if *expected != encoding { + return Err(BinaryReaderError::new( + format!( + "expected a version header for a {}", + match expected { + Encoding::Module => "module", + Encoding::Component => "component", + } + ), + range.start, + )); + } + } + } + _ => { + return Err(BinaryReaderError::new( + "wasm version header out of order", + range.start, + )) + } + } + + self.state = match (encoding, num) { + (Encoding::Module, WASM_MODULE_VERSION) => { + assert!(self.module.is_none()); + self.module = Some(ModuleState::default()); + State::Module + } + (Encoding::Component, WASM_COMPONENT_VERSION) => { + if !self.features.component_model { + return Err(BinaryReaderError::new( + "WebAssembly component model feature not enabled", + range.start, + )); + } + + self.components.push(ComponentState::default()); + State::Component + } + _ => { + return Err(BinaryReaderError::new( + "unknown binary version", + range.start, + )); + } + }; + + Ok(()) + } + + /// Validates [`Payload::TypeSection`](crate::Payload). + pub fn type_section(&mut self, section: &crate::TypeSectionReader<'_>) -> Result<()> { + self.process_module_section( + Order::Type, + section, + "type", + |state, _, types, count, offset| { + check_max( + state.module.types.len(), + count, + MAX_WASM_TYPES, + "types", + offset, + )?; + types.reserve(count as usize); + state.module.assert_mut().types.reserve(count as usize); + Ok(()) + }, + |state, features, types, def, offset| { + state + .module + .assert_mut() + .add_type(def, features, types, offset, false /* checked above */) + }, + ) + } + + /// Validates [`Payload::ImportSection`](crate::Payload). + /// + /// This method should only be called when parsing a module. + pub fn import_section(&mut self, section: &crate::ImportSectionReader<'_>) -> Result<()> { + self.process_module_section( + Order::Import, + section, + "import", + |_, _, _, _, _| Ok(()), // add_import will check limits + |state, features, types, import, offset| { + state + .module + .assert_mut() + .add_import(import, features, types, offset) + }, + ) + } + + /// Validates [`Payload::FunctionSection`](crate::Payload). + /// + /// This method should only be called when parsing a module. + pub fn function_section(&mut self, section: &crate::FunctionSectionReader<'_>) -> Result<()> { + self.process_module_section( + Order::Function, + section, + "function", + |state, _, _, count, offset| { + check_max( + state.module.functions.len(), + count, + MAX_WASM_FUNCTIONS, + "functions", + offset, + )?; + state.module.assert_mut().functions.reserve(count as usize); + debug_assert!(state.expected_code_bodies.is_none()); + state.expected_code_bodies = Some(count); + Ok(()) + }, + |state, _, types, ty, offset| state.module.assert_mut().add_function(ty, types, offset), + ) + } + + /// Validates [`Payload::TableSection`](crate::Payload). + /// + /// This method should only be called when parsing a module. + pub fn table_section(&mut self, section: &crate::TableSectionReader<'_>) -> Result<()> { + let features = self.features; + self.process_module_section( + Order::Table, + section, + "table", + |state, _, _, count, offset| { + check_max( + state.module.tables.len(), + count, + state.module.max_tables(&features), + "tables", + offset, + )?; + state.module.assert_mut().tables.reserve(count as usize); + Ok(()) + }, + |state, features, _, ty, offset| { + state.module.assert_mut().add_table(ty, features, offset) + }, + ) + } + + /// Validates [`Payload::MemorySection`](crate::Payload). + /// + /// This method should only be called when parsing a module. + pub fn memory_section(&mut self, section: &crate::MemorySectionReader<'_>) -> Result<()> { + self.process_module_section( + Order::Memory, + section, + "memory", + |state, features, _, count, offset| { + check_max( + state.module.memories.len(), + count, + state.module.max_memories(features), + "memories", + offset, + )?; + state.module.assert_mut().memories.reserve(count as usize); + Ok(()) + }, + |state, features, _, ty, offset| { + state.module.assert_mut().add_memory(ty, features, offset) + }, + ) + } + + /// Validates [`Payload::TagSection`](crate::Payload). + /// + /// This method should only be called when parsing a module. + pub fn tag_section(&mut self, section: &crate::TagSectionReader<'_>) -> Result<()> { + if !self.features.exceptions { + return Err(BinaryReaderError::new( + "exceptions proposal not enabled", + section.range().start, + )); + } + + self.process_module_section( + Order::Tag, + section, + "tag", + |state, _, _, count, offset| { + check_max( + state.module.tags.len(), + count, + MAX_WASM_TAGS, + "tags", + offset, + )?; + state.module.assert_mut().tags.reserve(count as usize); + Ok(()) + }, + |state, features, types, ty, offset| { + state + .module + .assert_mut() + .add_tag(ty, features, types, offset) + }, + ) + } + + /// Validates [`Payload::GlobalSection`](crate::Payload). + /// + /// This method should only be called when parsing a module. + pub fn global_section(&mut self, section: &crate::GlobalSectionReader<'_>) -> Result<()> { + self.process_module_section( + Order::Global, + section, + "global", + |state, _, _, count, offset| { + check_max( + state.module.globals.len(), + count, + MAX_WASM_GLOBALS, + "globals", + offset, + )?; + state.module.assert_mut().globals.reserve(count as usize); + Ok(()) + }, + |state, features, types, global, offset| { + state.add_global(global, features, types, offset) + }, + ) + } + + /// Validates [`Payload::ExportSection`](crate::Payload). + /// + /// This method should only be called when parsing a module. + pub fn export_section(&mut self, section: &crate::ExportSectionReader<'_>) -> Result<()> { + self.process_module_section( + Order::Export, + section, + "export", + |state, _, _, count, offset| { + check_max( + state.module.exports.len(), + count, + MAX_WASM_EXPORTS, + "exports", + offset, + )?; + state.module.assert_mut().exports.reserve(count as usize); + Ok(()) + }, + |state, features, _, e, offset| { + let state = state.module.assert_mut(); + let ty = state.export_to_entity_type(&e, offset)?; + state.add_export(e.name, ty, features, offset, false /* checked above */) + }, + ) + } + + /// Validates [`Payload::StartSection`](crate::Payload). + /// + /// This method should only be called when parsing a module. + pub fn start_section(&mut self, func: u32, range: &Range) -> Result<()> { + let offset = range.start; + self.state.ensure_module("start", offset)?; + let state = self.module.as_mut().unwrap(); + state.update_order(Order::Start, offset)?; + + let ty = state.module.get_func_type(func, &self.types, offset)?; + if !ty.params.is_empty() || !ty.returns.is_empty() { + return Err(BinaryReaderError::new( + "invalid start function type", + offset, + )); + } + + Ok(()) + } + + /// Validates [`Payload::ElementSection`](crate::Payload). + /// + /// This method should only be called when parsing a module. + pub fn element_section(&mut self, section: &crate::ElementSectionReader<'_>) -> Result<()> { + self.process_module_section( + Order::Element, + section, + "element", + |state, _, _, count, offset| { + check_max( + state.module.element_types.len(), + count, + MAX_WASM_ELEMENT_SEGMENTS, + "element segments", + offset, + )?; + state + .module + .assert_mut() + .element_types + .reserve(count as usize); + Ok(()) + }, + |state, features, types, e, offset| { + state.add_element_segment(e, features, types, offset) + }, + ) + } + + /// Validates [`Payload::DataCountSection`](crate::Payload). + /// + /// This method should only be called when parsing a module. + pub fn data_count_section(&mut self, count: u32, range: &Range) -> Result<()> { + let offset = range.start; + self.state.ensure_module("data count", offset)?; + + let state = self.module.as_mut().unwrap(); + state.update_order(Order::DataCount, offset)?; + + if count > MAX_WASM_DATA_SEGMENTS as u32 { + return Err(BinaryReaderError::new( + "data count section specifies too many data segments", + offset, + )); + } + + state.module.assert_mut().data_count = Some(count); + Ok(()) + } + + /// Validates [`Payload::CodeSectionStart`](crate::Payload). + /// + /// This method should only be called when parsing a module. + pub fn code_section_start(&mut self, count: u32, range: &Range) -> Result<()> { + let offset = range.start; + self.state.ensure_module("code", offset)?; + + let state = self.module.as_mut().unwrap(); + state.update_order(Order::Code, offset)?; + + match state.expected_code_bodies.take() { + Some(n) if n == count => {} + Some(_) => { + return Err(BinaryReaderError::new( + "function and code section have inconsistent lengths", + offset, + )); + } + // empty code sections are allowed even if the function section is + // missing + None if count == 0 => {} + None => { + return Err(BinaryReaderError::new( + "code section without function section", + offset, + )) + } + } + + // Take a snapshot of the types when we start the code section. + state.module.assert_mut().snapshot = Some(Arc::new(self.types.commit())); + + Ok(()) + } + + /// Validates [`Payload::CodeSectionEntry`](crate::Payload). + /// + /// This function will prepare a [`FuncValidator`] which can be used to + /// validate the function. The function body provided will be parsed only + /// enough to create the function validation context. After this the + /// [`OperatorsReader`](crate::readers::OperatorsReader) returned can be used to read the + /// opcodes of the function as well as feed information into the validator. + /// + /// Note that the returned [`FuncValidator`] is "connected" to this + /// [`Validator`] in that it uses the internal context of this validator for + /// validating the function. The [`FuncValidator`] can be sent to + /// another thread, for example, to offload actual processing of functions + /// elsewhere. + /// + /// This method should only be called when parsing a module. + pub fn code_section_entry( + &mut self, + body: &crate::FunctionBody, + ) -> Result> { + let offset = body.range().start; + self.state.ensure_module("code", offset)?; + + let state = self.module.as_mut().unwrap(); + + let (index, ty) = state.next_code_index_and_type(offset)?; + Ok(FuncValidator::new( + index, + ty, + 0, + ValidatorResources(state.module.arc().clone()), + &self.features, + ) + .unwrap()) + } + + /// Validates [`Payload::DataSection`](crate::Payload). + /// + /// This method should only be called when parsing a module. + pub fn data_section(&mut self, section: &crate::DataSectionReader<'_>) -> Result<()> { + self.process_module_section( + Order::Data, + section, + "data", + |state, _, _, count, offset| { + state.data_segment_count = count; + check_max( + state.module.data_count.unwrap_or(0) as usize, + count, + MAX_WASM_DATA_SEGMENTS, + "data segments", + offset, + ) + }, + |state, features, types, d, offset| state.add_data_segment(d, features, types, offset), + ) + } + + /// Validates [`Payload::ModuleSection`](crate::Payload). + /// + /// This method should only be called when parsing a component. + pub fn module_section(&mut self, range: &Range) -> Result<()> { + self.state.ensure_component("module", range.start)?; + + let current = self.components.last_mut().unwrap(); + check_max( + current.core_modules.len(), + 1, + MAX_WASM_MODULES, + "modules", + range.start, + )?; + + match mem::replace(&mut self.state, State::Unparsed(Some(Encoding::Module))) { + State::Component => {} + _ => unreachable!(), + } + + Ok(()) + } + + /// Validates [`Payload::InstanceSection`](crate::Payload). + /// + /// This method should only be called when parsing a component. + pub fn instance_section(&mut self, section: &crate::InstanceSectionReader) -> Result<()> { + self.process_component_section( + section, + "core instance", + |components, _, count, offset| { + let current = components.last_mut().unwrap(); + check_max( + current.instance_count(), + count, + MAX_WASM_INSTANCES, + "instances", + offset, + )?; + current.core_instances.reserve(count as usize); + Ok(()) + }, + |components, types, _, instance, offset| { + components + .last_mut() + .unwrap() + .add_core_instance(instance, types, offset) + }, + ) + } + + /// Validates [`Payload::AliasSection`](crate::Payload). + /// + /// This method should only be called when parsing a component. + pub fn alias_section(&mut self, section: &crate::AliasSectionReader) -> Result<()> { + self.process_component_section( + section, + "core alias", + |_, _, _, _| Ok(()), // maximums checked via `add_alias` + |components, types, _, alias, offset| -> Result<(), BinaryReaderError> { + ComponentState::add_core_alias(components, alias, types, offset) + }, + ) + } + + /// Validates [`Payload::CoreTypeSection`](crate::Payload). + /// + /// This method should only be called when parsing a component. + pub fn core_type_section(&mut self, section: &crate::CoreTypeSectionReader<'_>) -> Result<()> { + self.process_component_section( + section, + "core type", + |components, types, count, offset| { + let current = components.last_mut().unwrap(); + check_max(current.type_count(), count, MAX_WASM_TYPES, "types", offset)?; + types.reserve(count as usize); + current.core_types.reserve(count as usize); + Ok(()) + }, + |components, types, features, ty, offset| { + ComponentState::add_core_type( + components, ty, features, types, offset, false, /* checked above */ + ) + }, + ) + } + + /// Validates [`Payload::ComponentSection`](crate::Payload). + /// + /// This method should only be called when parsing a component. + pub fn component_section(&mut self, range: &Range) -> Result<()> { + self.state.ensure_component("component", range.start)?; + + let current = self.components.last_mut().unwrap(); + check_max( + current.components.len(), + 1, + MAX_WASM_COMPONENTS, + "components", + range.start, + )?; + + match mem::replace(&mut self.state, State::Unparsed(Some(Encoding::Component))) { + State::Component => {} + _ => unreachable!(), + } + + Ok(()) + } + + /// Validates [`Payload::ComponentInstanceSection`](crate::Payload). + /// + /// This method should only be called when parsing a component. + pub fn component_instance_section( + &mut self, + section: &crate::ComponentInstanceSectionReader, + ) -> Result<()> { + self.process_component_section( + section, + "instance", + |components, _, count, offset| { + let current = components.last_mut().unwrap(); + check_max( + current.instance_count(), + count, + MAX_WASM_INSTANCES, + "instances", + offset, + )?; + current.instances.reserve(count as usize); + Ok(()) + }, + |components, types, _, instance, offset| { + components + .last_mut() + .unwrap() + .add_instance(instance, types, offset) + }, + ) + } + + /// Validates [`Payload::ComponentAliasSection`](crate::Payload). + /// + /// This method should only be called when parsing a component. + pub fn component_alias_section( + &mut self, + section: &crate::ComponentAliasSectionReader, + ) -> Result<()> { + self.process_component_section( + section, + "alias", + |_, _, _, _| Ok(()), // maximums checked via `add_alias` + |components, types, _, alias, offset| -> Result<(), BinaryReaderError> { + ComponentState::add_alias(components, alias, types, offset) + }, + ) + } + + /// Validates [`Payload::ComponentTypeSection`](crate::Payload). + /// + /// This method should only be called when parsing a component. + pub fn component_type_section( + &mut self, + section: &crate::ComponentTypeSectionReader, + ) -> Result<()> { + self.process_component_section( + section, + "type", + |components, types, count, offset| { + let current = components.last_mut().unwrap(); + check_max(current.type_count(), count, MAX_WASM_TYPES, "types", offset)?; + types.reserve(count as usize); + current.types.reserve(count as usize); + Ok(()) + }, + |components, types, features, ty, offset| { + ComponentState::add_type( + components, ty, features, types, offset, false, /* checked above */ + ) + }, + ) + } + + /// Validates [`Payload::ComponentCanonicalSection`](crate::Payload). + /// + /// This method should only be called when parsing a component. + pub fn component_canonical_section( + &mut self, + section: &crate::ComponentCanonicalSectionReader, + ) -> Result<()> { + self.process_component_section( + section, + "function", + |components, _, count, offset| { + let current = components.last_mut().unwrap(); + check_max( + current.function_count(), + count, + MAX_WASM_FUNCTIONS, + "functions", + offset, + )?; + current.funcs.reserve(count as usize); + Ok(()) + }, + |components, types, _, func, offset| { + let current = components.last_mut().unwrap(); + match func { + crate::CanonicalFunction::Lift { + core_func_index, + type_index, + options, + } => current.lift_function( + core_func_index, + type_index, + options.into_vec(), + types, + offset, + ), + crate::CanonicalFunction::Lower { + func_index, + options, + } => current.lower_function(func_index, options.into_vec(), types, offset), + } + }, + ) + } + + /// Validates [`Payload::ComponentStartSection`](crate::Payload). + /// + /// This method should only be called when parsing a component. + pub fn component_start_section( + &mut self, + section: &crate::ComponentStartSectionReader, + ) -> Result<()> { + let range = section.range(); + self.state.ensure_component("start", range.start)?; + + let f = section.clone().read()?; + + self.components.last_mut().unwrap().add_start( + f.func_index, + &f.arguments, + &self.types, + range.start, + ) + } + + /// Validates [`Payload::ComponentImportSection`](crate::Payload). + /// + /// This method should only be called when parsing a component. + pub fn component_import_section( + &mut self, + section: &crate::ComponentImportSectionReader, + ) -> Result<()> { + self.process_component_section( + section, + "import", + |_, _, _, _| Ok(()), // add_import will check limits + |components, types, _, import, offset| { + components + .last_mut() + .unwrap() + .add_import(import, types, offset) + }, + ) + } + + /// Validates [`Payload::ComponentExportSection`](crate::Payload). + /// + /// This method should only be called when parsing a component. + pub fn component_export_section( + &mut self, + section: &crate::ComponentExportSectionReader, + ) -> Result<()> { + self.process_component_section( + section, + "export", + |components, _, count, offset| { + let current = components.last_mut().unwrap(); + check_max( + current.exports.len(), + count, + MAX_WASM_EXPORTS, + "exports", + offset, + )?; + current.exports.reserve(count as usize); + Ok(()) + }, + |components, _, _, export, offset| { + let current = components.last_mut().unwrap(); + let ty = current.export_to_entity_type(&export, offset)?; + current.add_export(export.name, ty, offset, false /* checked above */) + }, + ) + } + + /// Validates [`Payload::UnknownSection`](crate::Payload). + /// + /// Currently always returns an error. + pub fn unknown_section(&mut self, id: u8, range: &Range) -> Result<()> { + Err(BinaryReaderError::new( + format!("malformed section id: {}", id), + range.start, + )) + } + + /// Validates [`Payload::End`](crate::Payload). + /// + /// Returns the types known to the validator for the module or component. + pub fn end(&mut self, offset: usize) -> Result { + match std::mem::replace(&mut self.state, State::End) { + State::Unparsed(_) => Err(BinaryReaderError::new( + "cannot call `end` before a header has been parsed", + offset, + )), + State::End => Err(BinaryReaderError::new( + "cannot call `end` after parsing has completed", + offset, + )), + State::Module => { + let mut state = self.module.take().unwrap(); + state.validate_end(offset)?; + + // If there's a parent component, we'll add a module to the parent state + // and continue to validate the component + if let Some(parent) = self.components.last_mut() { + parent.add_core_module(&state.module, &mut self.types, offset)?; + self.state = State::Component; + } + + Ok(Types::from_module( + self.types.commit(), + state.module.arc().clone(), + )) + } + State::Component => { + let mut component = self.components.pop().unwrap(); + + // Validate that all values were used for the component + if let Some(index) = component.values.iter().position(|(_, used)| !*used) { + return Err(BinaryReaderError::new( + format!("value index {index} was not used as part of an instantiation, start function, or export"), + offset, + )); + } + + // If there's a parent component, pop the stack, add it to the parent, + // and continue to validate the component + if let Some(parent) = self.components.last_mut() { + parent.add_component(&mut component, &mut self.types); + self.state = State::Component; + } + + Ok(Types::from_component(self.types.commit(), component)) + } + } + } + + fn process_module_section( + &mut self, + order: Order, + section: &T, + name: &str, + validate_section: impl FnOnce( + &mut ModuleState, + &WasmFeatures, + &mut TypeList, + u32, + usize, + ) -> Result<()>, + mut validate_item: impl FnMut( + &mut ModuleState, + &WasmFeatures, + &mut TypeList, + T::Item, + usize, + ) -> Result<()>, + ) -> Result<()> + where + T: SectionReader + Clone + SectionWithLimitedItems, + { + let offset = section.range().start; + self.state.ensure_module(name, offset)?; + + let state = self.module.as_mut().unwrap(); + state.update_order(order, offset)?; + + validate_section( + state, + &self.features, + &mut self.types, + section.get_count(), + offset, + )?; + + let mut section = section.clone(); + for _ in 0..section.get_count() { + let offset = section.original_position(); + let item = section.read()?; + validate_item(state, &self.features, &mut self.types, item, offset)?; + } + + section.ensure_end()?; + + Ok(()) + } + + fn process_component_section( + &mut self, + section: &T, + name: &str, + validate_section: impl FnOnce(&mut Vec, &mut TypeList, u32, usize) -> Result<()>, + mut validate_item: impl FnMut( + &mut Vec, + &mut TypeList, + &WasmFeatures, + T::Item, + usize, + ) -> Result<()>, + ) -> Result<()> + where + T: SectionReader + Clone + SectionWithLimitedItems, + { + let offset = section.range().start; + + if !self.features.component_model { + return Err(BinaryReaderError::new( + "component model feature is not enabled", + offset, + )); + } + + self.state.ensure_component(name, offset)?; + validate_section( + &mut self.components, + &mut self.types, + section.get_count(), + offset, + )?; + + let mut section = section.clone(); + for _ in 0..section.get_count() { + let offset = section.original_position(); + let item = section.read()?; + validate_item( + &mut self.components, + &mut self.types, + &self.features, + item, + offset, + )?; + } + + section.ensure_end()?; + + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use crate::{GlobalType, MemoryType, TableType, ValType, Validator, WasmFeatures}; + use anyhow::Result; + + #[test] + fn test_module_type_information() -> Result<()> { + let bytes = wat::parse_str( + r#" + (module + (type (func (param i32 i64) (result i32))) + (memory 1 5) + (table 10 funcref) + (global (mut i32) (i32.const 0)) + (func (type 0) (i32.const 0)) + (tag (param i64 i32)) + (elem funcref (ref.func 0)) + ) + "#, + )?; + + let mut validator = Validator::new_with_features(WasmFeatures { + exceptions: true, + ..Default::default() + }); + + let types = validator.validate_all(&bytes)?; + + assert_eq!(types.type_count(), 2); + assert_eq!(types.memory_count(), 1); + assert_eq!(types.table_count(), 1); + assert_eq!(types.global_count(), 1); + assert_eq!(types.function_count(), 1); + assert_eq!(types.tag_count(), 1); + assert_eq!(types.element_count(), 1); + assert_eq!(types.module_count(), 0); + assert_eq!(types.component_count(), 0); + assert_eq!(types.instance_count(), 0); + assert_eq!(types.value_count(), 0); + + match types.func_type_at(0) { + Some(ty) => { + assert_eq!(ty.params.as_ref(), [ValType::I32, ValType::I64]); + assert_eq!(ty.returns.as_ref(), [ValType::I32]); + } + _ => unreachable!(), + } + + match types.func_type_at(1) { + Some(ty) => { + assert_eq!(ty.params.as_ref(), [ValType::I64, ValType::I32]); + assert_eq!(ty.returns.as_ref(), []); + } + _ => unreachable!(), + } + + assert_eq!( + types.memory_at(0), + Some(MemoryType { + memory64: false, + shared: false, + initial: 1, + maximum: Some(5) + }) + ); + + assert_eq!( + types.table_at(0), + Some(TableType { + initial: 10, + maximum: None, + element_type: ValType::FuncRef, + }) + ); + + assert_eq!( + types.global_at(0), + Some(GlobalType { + content_type: ValType::I32, + mutable: true + }) + ); + + match types.function_at(0) { + Some(ty) => { + assert_eq!(ty.params.as_ref(), [ValType::I32, ValType::I64]); + assert_eq!(ty.returns.as_ref(), [ValType::I32]); + } + _ => unreachable!(), + } + + match types.tag_at(0) { + Some(ty) => { + assert_eq!(ty.params.as_ref(), [ValType::I64, ValType::I32]); + assert_eq!(ty.returns.as_ref(), []); + } + _ => unreachable!(), + } + + assert_eq!(types.element_at(0), Some(ValType::FuncRef)); + + Ok(()) + } +} diff --git a/crates/wasmparser/src/validator/component.rs b/crates/wasmparser/src/validator/component.rs new file mode 100644 index 000000000..d670600d9 --- /dev/null +++ b/crates/wasmparser/src/validator/component.rs @@ -0,0 +1,2087 @@ +//! State relating to validating a WebAssembly component. + +use super::{ + check_max, combine_type_sizes, + core::Module, + types::{ + ComponentFuncType, ComponentInstanceType, ComponentInstanceTypeKind, ComponentType, + ComponentValType, EntityType, InstanceType, ModuleType, RecordType, Type, TypeId, TypeList, + VariantCase, + }, +}; +use crate::{ + limits::*, + types::{ + ComponentDefinedType, ComponentEntityType, InstanceTypeKind, LoweringInfo, TupleType, + UnionType, VariantType, + }, + BinaryReaderError, CanonicalOption, ComponentExternalKind, ComponentOuterAliasKind, + ComponentTypeRef, ExternalKind, FuncType, GlobalType, InstantiationArgKind, MemoryType, Result, + TableType, TypeBounds, ValType, WasmFeatures, +}; +use indexmap::{IndexMap, IndexSet}; +use std::{collections::HashSet, mem}; + +pub(crate) struct ComponentState { + // Core index spaces + pub core_types: Vec, + pub core_modules: Vec, + pub core_instances: Vec, + pub core_funcs: Vec, + pub core_memories: Vec, + pub core_tables: Vec, + pub core_globals: Vec, + pub core_tags: Vec, + + // Component index spaces + pub types: Vec, + pub funcs: Vec, + pub values: Vec<(ComponentValType, bool)>, + pub instances: Vec, + pub components: Vec, + + pub imports: IndexMap, + pub exports: IndexMap, + has_start: bool, + type_size: usize, +} + +impl ComponentState { + pub fn type_count(&self) -> usize { + self.core_types.len() + self.types.len() + } + + pub fn instance_count(&self) -> usize { + self.core_instances.len() + self.instances.len() + } + + pub fn function_count(&self) -> usize { + self.core_funcs.len() + self.funcs.len() + } + + pub fn add_core_type( + components: &mut [Self], + ty: crate::CoreType, + features: &WasmFeatures, + types: &mut TypeList, + offset: usize, + check_limit: bool, + ) -> Result<()> { + let ty = match ty { + crate::CoreType::Func(ty) => Type::Func(ty), + crate::CoreType::Module(decls) => Type::Module(Self::create_module_type( + components, + decls.into_vec(), + features, + types, + offset, + )?), + }; + + let current = components.last_mut().unwrap(); + + if check_limit { + check_max(current.type_count(), 1, MAX_WASM_TYPES, "types", offset)?; + } + + current.core_types.push(TypeId { + type_size: ty.type_size(), + index: types.len(), + }); + types.push(ty); + + Ok(()) + } + + pub fn add_core_module( + &mut self, + module: &Module, + types: &mut TypeList, + offset: usize, + ) -> Result<()> { + let imports = module.imports_for_module_type(offset)?; + + // We have to clone the module's imports and exports here + // because we cannot take the data out of the `MaybeOwned` + // as it might be shared with a function validator. + let ty = Type::Module(ModuleType { + type_size: module.type_size, + imports, + exports: module.exports.clone(), + }); + + self.core_modules.push(TypeId { + type_size: ty.type_size(), + index: types.len(), + }); + + types.push(ty); + + Ok(()) + } + + pub fn add_core_instance( + &mut self, + instance: crate::Instance, + types: &mut TypeList, + offset: usize, + ) -> Result<()> { + let instance = match instance { + crate::Instance::Instantiate { module_index, args } => { + self.instantiate_module(module_index, args.into_vec(), types, offset)? + } + crate::Instance::FromExports(exports) => { + self.instantiate_core_exports(exports.into_vec(), types, offset)? + } + }; + + self.core_instances.push(instance); + + Ok(()) + } + + pub fn add_core_alias( + components: &mut [Self], + alias: crate::Alias, + types: &TypeList, + offset: usize, + ) -> Result<()> { + match alias { + crate::Alias::InstanceExport { + instance_index, + kind, + name, + } => components.last_mut().unwrap().alias_core_instance_export( + instance_index, + kind, + name, + types, + offset, + ), + crate::Alias::Outer { kind, count, index } => match kind { + crate::OuterAliasKind::Type => { + Self::alias_core_type(components, count, index, offset) + } + }, + } + } + + pub fn add_type( + components: &mut Vec, + ty: crate::ComponentType, + features: &WasmFeatures, + types: &mut TypeList, + offset: usize, + check_limit: bool, + ) -> Result<()> { + assert!(!components.is_empty()); + let ty = match ty { + crate::ComponentType::Defined(ty) => Type::Defined( + components + .last_mut() + .unwrap() + .create_defined_type(ty, types, offset)?, + ), + crate::ComponentType::Func(ty) => Type::ComponentFunc( + components + .last_mut() + .unwrap() + .create_function_type(ty, types, offset)?, + ), + crate::ComponentType::Component(decls) => Type::Component(Self::create_component_type( + components, + decls.into_vec(), + features, + types, + offset, + )?), + crate::ComponentType::Instance(decls) => Type::ComponentInstance( + Self::create_instance_type(components, decls.into_vec(), features, types, offset)?, + ), + }; + + let current = components.last_mut().unwrap(); + if check_limit { + check_max(current.type_count(), 1, MAX_WASM_TYPES, "types", offset)?; + } + + current.types.push(TypeId { + type_size: ty.type_size(), + index: types.len(), + }); + types.push(ty); + + Ok(()) + } + + pub fn add_import( + &mut self, + import: crate::ComponentImport, + types: &TypeList, + offset: usize, + ) -> Result<()> { + let entity = self.check_type_ref(&import.ty, types, offset)?; + + let (len, max, desc) = match entity { + ComponentEntityType::Module(id) => { + self.core_modules.push(id); + (self.core_modules.len(), MAX_WASM_MODULES, "modules") + } + ComponentEntityType::Component(id) => { + self.components.push(id); + (self.components.len(), MAX_WASM_COMPONENTS, "components") + } + ComponentEntityType::Instance(id) => { + self.instances.push(id); + (self.instance_count(), MAX_WASM_INSTANCES, "instances") + } + ComponentEntityType::Func(id) => { + self.funcs.push(id); + (self.function_count(), MAX_WASM_FUNCTIONS, "functions") + } + ComponentEntityType::Value(ty) => { + self.values.push((ty, false)); + (self.values.len(), MAX_WASM_VALUES, "values") + } + ComponentEntityType::Type(id) => { + self.types.push(id); + (self.types.len(), MAX_WASM_TYPES, "types") + } + }; + + check_max(len, 0, max, desc, offset)?; + + self.type_size = combine_type_sizes(self.type_size, entity.type_size(), offset)?; + + if self + .imports + .insert(import.name.to_string(), entity) + .is_some() + { + return Err(BinaryReaderError::new( + format!("duplicate import name `{}` already defined", import.name), + offset, + )); + } + + Ok(()) + } + + pub fn add_export( + &mut self, + name: &str, + ty: ComponentEntityType, + offset: usize, + check_limit: bool, + ) -> Result<()> { + if check_limit { + check_max(self.exports.len(), 1, MAX_WASM_EXPORTS, "exports", offset)?; + } + + self.type_size = combine_type_sizes(self.type_size, ty.type_size(), offset)?; + + if self.exports.insert(name.to_string(), ty).is_some() { + return Err(BinaryReaderError::new( + format!("duplicate export name `{}` already defined", name), + offset, + )); + } + + Ok(()) + } + + pub fn lift_function( + &mut self, + core_func_index: u32, + type_index: u32, + options: Vec, + types: &TypeList, + offset: usize, + ) -> Result<()> { + let ty = self.function_type_at(type_index, types, offset)?; + let core_ty = types[self.core_function_at(core_func_index, offset)?] + .as_func_type() + .unwrap(); + + // Lifting a function is for an export, so match the expected canonical ABI + // export signature + let info = ty.lower(types, false); + self.check_options(Some(core_ty), &info, &options, types, offset)?; + + if core_ty.params.as_ref() != info.params.as_slice() { + return Err(BinaryReaderError::new( + format!( + "lowered parameter types `{:?}` do not match parameter types `{:?}` of core function {core_func_index}", + info.params.as_slice(), + core_ty.params + ), + offset, + )); + } + + if core_ty.returns.as_ref() != info.results.as_slice() { + return Err(BinaryReaderError::new( + format!( + "lowered result types `{:?}` do not match result types `{:?}` of core function {core_func_index}", + info.results.as_slice(), + core_ty.returns + ), + offset, + )); + } + + self.funcs.push(self.types[type_index as usize]); + + Ok(()) + } + + pub fn lower_function( + &mut self, + func_index: u32, + options: Vec, + types: &mut TypeList, + offset: usize, + ) -> Result<()> { + let ty = types[self.function_at(func_index, offset)?] + .as_component_func_type() + .unwrap(); + + // Lowering a function is for an import, so use a function type that matches + // the expected canonical ABI import signature. + let info = ty.lower(types, true); + + self.check_options(None, &info, &options, types, offset)?; + + let lowered_ty = Type::Func(info.into_func_type()); + + self.core_funcs.push(TypeId { + type_size: lowered_ty.type_size(), + index: types.len(), + }); + + types.push(lowered_ty); + + Ok(()) + } + + pub fn add_component(&mut self, component: &mut Self, types: &mut TypeList) { + let ty = Type::Component(ComponentType { + type_size: component.type_size, + imports: mem::take(&mut component.imports), + exports: mem::take(&mut component.exports), + }); + + self.components.push(TypeId { + type_size: ty.type_size(), + index: types.len(), + }); + + types.push(ty); + } + + pub fn add_instance( + &mut self, + instance: crate::ComponentInstance, + types: &mut TypeList, + offset: usize, + ) -> Result<()> { + let instance = match instance { + crate::ComponentInstance::Instantiate { + component_index, + args, + } => self.instantiate_component(component_index, args.into_vec(), types, offset)?, + crate::ComponentInstance::FromExports(exports) => { + self.instantiate_exports(exports.into_vec(), types, offset)? + } + }; + + self.instances.push(instance); + + Ok(()) + } + + pub fn add_alias( + components: &mut [Self], + alias: crate::ComponentAlias, + types: &TypeList, + offset: usize, + ) -> Result<()> { + match alias { + crate::ComponentAlias::InstanceExport { + instance_index, + kind, + name, + } => components.last_mut().unwrap().alias_instance_export( + instance_index, + kind, + name, + types, + offset, + ), + crate::ComponentAlias::Outer { kind, count, index } => match kind { + ComponentOuterAliasKind::CoreModule => { + Self::alias_module(components, count, index, offset) + } + ComponentOuterAliasKind::CoreType => { + Self::alias_core_type(components, count, index, offset) + } + ComponentOuterAliasKind::Type => Self::alias_type(components, count, index, offset), + ComponentOuterAliasKind::Component => { + Self::alias_component(components, count, index, offset) + } + }, + } + } + + pub fn add_start( + &mut self, + func_index: u32, + args: &[u32], + types: &TypeList, + offset: usize, + ) -> Result<()> { + if self.has_start { + return Err(BinaryReaderError::new( + "component cannot have more than one start function", + offset, + )); + } + + let ft = types[self.function_at(func_index, offset)?] + .as_component_func_type() + .unwrap(); + + if ft.params.len() != args.len() { + return Err(BinaryReaderError::new( + format!( + "component start function requires {} arguments but was given {}", + ft.params.len(), + args.len() + ), + offset, + )); + } + + for (i, ((_, ty), arg)) in ft.params.iter().zip(args).enumerate() { + // Ensure the value's type is a subtype of the parameter type + if !ComponentValType::internal_is_subtype_of( + self.value_at(*arg, offset)?, + types, + ty, + types, + ) { + return Err(BinaryReaderError::new( + format!( + "value type mismatch for component start function argument {}", + i + ), + offset, + )); + } + } + + for (_, ty) in ft.results.iter() { + self.values.push((*ty, false)); + } + + self.has_start = true; + + Ok(()) + } + + fn check_options( + &self, + core_ty: Option<&FuncType>, + info: &LoweringInfo, + options: &[CanonicalOption], + types: &TypeList, + offset: usize, + ) -> Result<()> { + fn display(option: CanonicalOption) -> &'static str { + match option { + CanonicalOption::UTF8 => "utf8", + CanonicalOption::UTF16 => "utf16", + CanonicalOption::CompactUTF16 => "latin1-utf16", + CanonicalOption::Memory(_) => "memory", + CanonicalOption::Realloc(_) => "realloc", + CanonicalOption::PostReturn(_) => "post-return", + } + } + + let mut encoding = None; + let mut memory = None; + let mut realloc = None; + let mut post_return = None; + + for option in options { + match option { + CanonicalOption::UTF8 | CanonicalOption::UTF16 | CanonicalOption::CompactUTF16 => { + match encoding { + Some(existing) => { + return Err(BinaryReaderError::new( + format!( + "canonical encoding option `{}` conflicts with option `{}`", + display(existing), + display(*option), + ), + offset, + )) + } + None => encoding = Some(*option), + } + } + CanonicalOption::Memory(idx) => { + memory = match memory { + None => { + self.memory_at(*idx, offset)?; + Some(*idx) + } + Some(_) => { + return Err(BinaryReaderError::new( + "canonical option `memory` is specified more than once", + offset, + )) + } + } + } + CanonicalOption::Realloc(idx) => { + realloc = match realloc { + None => { + let ty = types[self.core_function_at(*idx, offset)?] + .as_func_type() + .unwrap(); + if ty.params.as_ref() + != [ValType::I32, ValType::I32, ValType::I32, ValType::I32] + || ty.returns.as_ref() != [ValType::I32] + { + return Err(BinaryReaderError::new( + "canonical option `realloc` uses a core function with an incorrect signature", + offset, + )); + } + Some(*idx) + } + Some(_) => { + return Err(BinaryReaderError::new( + "canonical option `realloc` is specified more than once", + offset, + )) + } + } + } + CanonicalOption::PostReturn(idx) => { + post_return = match post_return { + None => { + let core_ty = core_ty.ok_or_else(|| { + BinaryReaderError::new( + "canonical option `post-return` cannot be specified for lowerings", + offset, + ) + })?; + + let ty = types[self.core_function_at(*idx, offset)?] + .as_func_type() + .unwrap(); + + if ty.params != core_ty.returns || !ty.returns.is_empty() { + return Err(BinaryReaderError::new( + "canonical option `post-return` uses a core function with an incorrect signature", + offset, + )); + } + Some(*idx) + } + Some(_) => { + return Err(BinaryReaderError::new( + "canonical option `post-return` is specified more than once", + offset, + )) + } + } + } + } + } + + if info.requires_memory && memory.is_none() { + return Err(BinaryReaderError::new( + "canonical option `memory` is required", + offset, + )); + } + + if info.requires_realloc && realloc.is_none() { + return Err(BinaryReaderError::new( + "canonical option `realloc` is required", + offset, + )); + } + + Ok(()) + } + + pub fn check_type_ref( + &self, + ty: &ComponentTypeRef, + types: &TypeList, + offset: usize, + ) -> Result { + Ok(match ty { + ComponentTypeRef::Module(index) => { + let id = self.type_at(*index, true, offset)?; + types[id].as_module_type().ok_or_else(|| { + BinaryReaderError::new( + format!("core type index {} is not a module type", index), + offset, + ) + })?; + ComponentEntityType::Module(id) + } + ComponentTypeRef::Func(index) => { + let id = self.type_at(*index, false, offset)?; + types[id].as_component_func_type().ok_or_else(|| { + BinaryReaderError::new( + format!("type index {} is not a function type", index), + offset, + ) + })?; + ComponentEntityType::Func(id) + } + ComponentTypeRef::Value(ty) => { + let ty = match ty { + crate::ComponentValType::Primitive(ty) => ComponentValType::Primitive(*ty), + crate::ComponentValType::Type(index) => { + ComponentValType::Type(self.defined_type_at(*index, types, offset)?) + } + }; + ComponentEntityType::Value(ty) + } + ComponentTypeRef::Type(TypeBounds::Eq, index) => { + ComponentEntityType::Type(self.type_at(*index, false, offset)?) + } + ComponentTypeRef::Instance(index) => { + let id = self.type_at(*index, false, offset)?; + types[id].as_component_instance_type().ok_or_else(|| { + BinaryReaderError::new( + format!("type index {} is not an instance type", index), + offset, + ) + })?; + ComponentEntityType::Instance(id) + } + ComponentTypeRef::Component(index) => { + let id = self.type_at(*index, false, offset)?; + types[id].as_component_type().ok_or_else(|| { + BinaryReaderError::new( + format!("type index {} is not a component type", index), + offset, + ) + })?; + ComponentEntityType::Component(id) + } + }) + } + + pub fn export_to_entity_type( + &mut self, + export: &crate::ComponentExport, + offset: usize, + ) -> Result { + Ok(match export.kind { + ComponentExternalKind::Module => { + ComponentEntityType::Module(self.module_at(export.index, offset)?) + } + ComponentExternalKind::Func => { + ComponentEntityType::Func(self.function_at(export.index, offset)?) + } + ComponentExternalKind::Value => { + ComponentEntityType::Value(*self.value_at(export.index, offset)?) + } + ComponentExternalKind::Type => { + ComponentEntityType::Type(self.type_at(export.index, false, offset)?) + } + ComponentExternalKind::Instance => { + ComponentEntityType::Instance(self.instance_at(export.index, offset)?) + } + ComponentExternalKind::Component => { + ComponentEntityType::Component(self.component_at(export.index, offset)?) + } + }) + } + + fn create_module_type( + components: &[Self], + decls: Vec, + features: &WasmFeatures, + types: &mut TypeList, + offset: usize, + ) -> Result { + let mut state = Module::default(); + + for decl in decls { + match decl { + crate::ModuleTypeDeclaration::Type(ty) => { + state.add_type(ty, features, types, offset, true)?; + } + crate::ModuleTypeDeclaration::Export { name, ty } => { + let ty = state.check_type_ref(&ty, features, types, offset)?; + state.add_export(name, ty, features, offset, true)?; + } + crate::ModuleTypeDeclaration::Alias(alias) => match alias { + crate::Alias::InstanceExport { .. } => { + return Err(BinaryReaderError::new( + "only outer type aliases are allowed in module type declarations", + offset, + )) + } + crate::Alias::Outer { kind, count, index } => { + if count > 1 { + return Err(BinaryReaderError::new( + "outer type aliases in module type declarations are limited to a maximum count of 1", + offset, + )); + } + match kind { + crate::OuterAliasKind::Type => { + let ty = if count == 0 { + // Local alias, check the local module state + state.type_at(index, offset)? + } else { + // Otherwise, check the enclosing component state + let component = + Self::check_alias_count(components, count - 1, offset)?; + component.type_at(index, true, offset)? + }; + + check_max(state.types.len(), 1, MAX_WASM_TYPES, "types", offset)?; + + state.types.push(ty); + } + } + } + }, + crate::ModuleTypeDeclaration::Import(import) => { + state.add_import(import, features, types, offset)?; + } + } + } + + let imports = state.imports_for_module_type(offset)?; + + Ok(ModuleType { + type_size: state.type_size, + imports, + exports: state.exports, + }) + } + + fn create_component_type( + components: &mut Vec, + decls: Vec, + features: &WasmFeatures, + types: &mut TypeList, + offset: usize, + ) -> Result { + components.push(ComponentState::default()); + + for decl in decls { + match decl { + crate::ComponentTypeDeclaration::CoreType(ty) => { + Self::add_core_type(components, ty, features, types, offset, true)?; + } + crate::ComponentTypeDeclaration::Type(ty) => { + Self::add_type(components, ty, features, types, offset, true)?; + } + crate::ComponentTypeDeclaration::Export { name, ty } => { + let current = components.last_mut().unwrap(); + let ty = current.check_type_ref(&ty, types, offset)?; + current.add_export(name, ty, offset, true)?; + } + crate::ComponentTypeDeclaration::Import(import) => { + components + .last_mut() + .unwrap() + .add_import(import, types, offset)?; + } + crate::ComponentTypeDeclaration::Alias(alias) => { + match alias { + crate::ComponentAlias::Outer { kind, count, index } + if kind == ComponentOuterAliasKind::CoreType + || kind == ComponentOuterAliasKind::Type => + { + match kind { + ComponentOuterAliasKind::CoreType => { + Self::alias_core_type(components, count, index, offset)? + } + ComponentOuterAliasKind::Type => { + Self::alias_type(components, count, index, offset)? + } + _ => unreachable!(), + } + } + _ => return Err(BinaryReaderError::new( + "only outer type aliases are allowed in component type declarations", + offset, + )), + } + } + }; + } + + let state = components.pop().unwrap(); + + Ok(ComponentType { + type_size: state.type_size, + imports: state.imports, + exports: state.exports, + }) + } + + fn create_instance_type( + components: &mut Vec, + decls: Vec, + features: &WasmFeatures, + types: &mut TypeList, + offset: usize, + ) -> Result { + components.push(ComponentState::default()); + + for decl in decls { + match decl { + crate::InstanceTypeDeclaration::CoreType(ty) => { + Self::add_core_type(components, ty, features, types, offset, true)?; + } + crate::InstanceTypeDeclaration::Type(ty) => { + Self::add_type(components, ty, features, types, offset, true)?; + } + crate::InstanceTypeDeclaration::Export { name, ty } => { + let current = components.last_mut().unwrap(); + let ty = current.check_type_ref(&ty, types, offset)?; + current.add_export(name, ty, offset, true)?; + } + crate::InstanceTypeDeclaration::Alias(alias) => match alias { + crate::ComponentAlias::Outer { kind, count, index } + if kind == ComponentOuterAliasKind::CoreType + || kind == ComponentOuterAliasKind::Type => + { + match kind { + ComponentOuterAliasKind::CoreType => { + Self::alias_core_type(components, count, index, offset)? + } + ComponentOuterAliasKind::Type => { + Self::alias_type(components, count, index, offset)? + } + _ => unreachable!(), + } + } + _ => { + return Err(BinaryReaderError::new( + "only outer type aliases are allowed in instance type declarations", + offset, + )) + } + }, + }; + } + + let state = components.pop().unwrap(); + + Ok(ComponentInstanceType { + type_size: state.type_size, + kind: ComponentInstanceTypeKind::Defined(state.exports), + }) + } + + fn create_function_type( + &self, + ty: crate::ComponentFuncType, + types: &TypeList, + offset: usize, + ) -> Result { + let mut type_size = 1; + + let mut set = HashSet::with_capacity(std::cmp::max(ty.params.len(), ty.results.len())); + + let params = ty + .params + .iter() + .map(|(name, ty)| { + if let Some(name) = name { + Self::check_name(name, "function parameter", offset)?; + if !set.insert(name) { + return Err(BinaryReaderError::new("duplicate parameter name", offset)); + } + } + let ty = self.create_component_val_type(*ty, types, offset)?; + type_size = combine_type_sizes(type_size, ty.type_size(), offset)?; + Ok((name.map(ToOwned::to_owned), ty)) + }) + .collect::>()?; + + set.clear(); + + let results = ty + .results + .iter() + .map(|(name, ty)| { + if let Some(name) = name { + Self::check_name(name, "function result", offset)?; + if !set.insert(name) { + return Err(BinaryReaderError::new("duplicate result name", offset)); + } + } + let ty = self.create_component_val_type(*ty, types, offset)?; + type_size = combine_type_sizes(type_size, ty.type_size(), offset)?; + Ok((name.map(ToOwned::to_owned), ty)) + }) + .collect::>()?; + + Ok(ComponentFuncType { + type_size, + params, + results, + }) + } + + fn check_name(name: &str, desc: &str, offset: usize) -> Result<()> { + if name.is_empty() { + return Err(BinaryReaderError::new( + format!("{} name cannot be empty", desc), + offset, + )); + } + + Ok(()) + } + + fn instantiate_module( + &self, + module_index: u32, + module_args: Vec, + types: &mut TypeList, + offset: usize, + ) -> Result { + fn insert_arg<'a>( + name: &'a str, + arg: &'a InstanceType, + args: &mut IndexMap<&'a str, &'a InstanceType>, + offset: usize, + ) -> Result<()> { + if args.insert(name, arg).is_some() { + return Err(BinaryReaderError::new( + format!("duplicate module instantiation argument named `{}`", name), + offset, + )); + } + + Ok(()) + } + + let module_type_id = self.module_at(module_index, offset)?; + let mut args = IndexMap::new(); + + // Populate the arguments + for module_arg in module_args { + match module_arg.kind { + InstantiationArgKind::Instance => { + let instance_type = types[self.core_instance_at(module_arg.index, offset)?] + .as_instance_type() + .unwrap(); + insert_arg(module_arg.name, instance_type, &mut args, offset)?; + } + } + } + + // Validate the arguments + let module_type = types[module_type_id].as_module_type().unwrap(); + for ((module, name), expected) in module_type.imports.iter() { + let instance = args.get(module.as_str()).ok_or_else(|| { + BinaryReaderError::new( + format!("missing module instantiation argument named `{}`", module), + offset, + ) + })?; + + let arg = instance + .internal_exports(types) + .get(name.as_str()) + .ok_or_else(|| { + BinaryReaderError::new( + format!( + "module instantiation argument `{}` does not export an item named `{}`", + module, name, + ), + offset, + ) + })?; + + match (arg, expected) { + (EntityType::Func(_), EntityType::Func(_)) | + (EntityType::Table(_), EntityType::Table(_)) | + (EntityType::Memory(_), EntityType::Memory(_)) | + (EntityType::Global(_), EntityType::Global(_)) | + (EntityType::Tag(_), EntityType::Tag(_)) => {}, + _ => { + return Err(BinaryReaderError::new( + format!( + "module instantiation argument `{}` exports an item named `{}` but it is not a {}", + module, + name, + expected.desc() + ), + offset, + )) + } + } + + if !EntityType::internal_is_subtype_of(arg, types, expected, types) { + return Err(BinaryReaderError::new( + format!( + "{} type mismatch for export `{}` of module instantiation argument `{}`", + expected.desc(), + name, + module, + ), + offset, + )); + } + } + + let ty = Type::Instance(InstanceType { + type_size: module_type + .exports + .iter() + .fold(1, |acc, (_, ty)| acc + ty.type_size()), + kind: InstanceTypeKind::Instantiated(module_type_id), + }); + + let id = TypeId { + type_size: ty.type_size(), + index: types.len(), + }; + + types.push(ty); + + Ok(id) + } + + fn instantiate_component( + &mut self, + component_index: u32, + component_args: Vec, + types: &mut TypeList, + offset: usize, + ) -> Result { + fn insert_arg<'a>( + name: &'a str, + arg: ComponentEntityType, + args: &mut IndexMap<&'a str, ComponentEntityType>, + offset: usize, + ) -> Result<()> { + if args.insert(name, arg).is_some() { + return Err(BinaryReaderError::new( + format!( + "duplicate component instantiation argument named `{}`", + name + ), + offset, + )); + } + + Ok(()) + } + + let component_type_id = self.component_at(component_index, offset)?; + let mut args = IndexMap::new(); + + // Populate the arguments + for component_arg in component_args { + match component_arg.kind { + ComponentExternalKind::Module => { + insert_arg( + component_arg.name, + ComponentEntityType::Module(self.module_at(component_arg.index, offset)?), + &mut args, + offset, + )?; + } + ComponentExternalKind::Component => { + insert_arg( + component_arg.name, + ComponentEntityType::Component( + self.component_at(component_arg.index, offset)?, + ), + &mut args, + offset, + )?; + } + ComponentExternalKind::Instance => { + insert_arg( + component_arg.name, + ComponentEntityType::Instance( + self.instance_at(component_arg.index, offset)?, + ), + &mut args, + offset, + )?; + } + ComponentExternalKind::Func => { + insert_arg( + component_arg.name, + ComponentEntityType::Func(self.function_at(component_arg.index, offset)?), + &mut args, + offset, + )?; + } + ComponentExternalKind::Value => { + insert_arg( + component_arg.name, + ComponentEntityType::Value(*self.value_at(component_arg.index, offset)?), + &mut args, + offset, + )?; + } + ComponentExternalKind::Type => { + // Type arguments are ignored + } + } + } + + // Validate the arguments + let component_type = types[component_type_id].as_component_type().unwrap(); + for (name, expected) in component_type.imports.iter() { + match args.get(name.as_str()) { + Some(arg) => { + match (arg, expected) { + (ComponentEntityType::Module(_), ComponentEntityType::Module(_)) + | (ComponentEntityType::Component(_), ComponentEntityType::Component(_)) + | (ComponentEntityType::Instance(_), ComponentEntityType::Instance(_)) + | (ComponentEntityType::Func(_), ComponentEntityType::Func(_)) + | (ComponentEntityType::Value(_), ComponentEntityType::Value(_)) => {} + _ => { + return Err(BinaryReaderError::new( + format!( + "expected component instantiation argument `{}` to be of type `{}`", + name, + expected.desc() + ), + offset, + )) + } + }; + + if !ComponentEntityType::internal_is_subtype_of(arg, types, expected, types) { + return Err(BinaryReaderError::new( + format!( + "{} type mismatch for component instantiation argument `{}`", + expected.desc(), + name + ), + offset, + )); + } + } + None => { + return Err(BinaryReaderError::new( + format!("missing component instantiation argument named `{}`", name), + offset, + )) + } + } + } + + let ty = Type::ComponentInstance(ComponentInstanceType { + type_size: component_type + .exports + .iter() + .fold(1, |acc, (_, ty)| acc + ty.type_size()), + kind: ComponentInstanceTypeKind::Instantiated(component_type_id), + }); + + let id = TypeId { + type_size: ty.type_size(), + index: types.len(), + }; + + types.push(ty); + + Ok(id) + } + + fn instantiate_exports( + &mut self, + exports: Vec, + types: &mut TypeList, + offset: usize, + ) -> Result { + fn insert_export( + name: &str, + export: ComponentEntityType, + exports: &mut IndexMap, + type_size: &mut usize, + offset: usize, + ) -> Result<()> { + *type_size = combine_type_sizes(*type_size, export.type_size(), offset)?; + + if exports.insert(name.to_string(), export).is_some() { + return Err(BinaryReaderError::new( + format!( + "duplicate instantiation export name `{}` already defined", + name + ), + offset, + )); + } + + Ok(()) + } + + let mut type_size = 1; + let mut inst_exports = IndexMap::new(); + for export in exports { + match export.kind { + ComponentExternalKind::Module => { + insert_export( + export.name, + ComponentEntityType::Module(self.module_at(export.index, offset)?), + &mut inst_exports, + &mut type_size, + offset, + )?; + } + ComponentExternalKind::Component => { + insert_export( + export.name, + ComponentEntityType::Component(self.component_at(export.index, offset)?), + &mut inst_exports, + &mut type_size, + offset, + )?; + } + ComponentExternalKind::Instance => { + insert_export( + export.name, + ComponentEntityType::Instance(self.instance_at(export.index, offset)?), + &mut inst_exports, + &mut type_size, + offset, + )?; + } + ComponentExternalKind::Func => { + insert_export( + export.name, + ComponentEntityType::Func(self.function_at(export.index, offset)?), + &mut inst_exports, + &mut type_size, + offset, + )?; + } + ComponentExternalKind::Value => { + insert_export( + export.name, + ComponentEntityType::Value(*self.value_at(export.index, offset)?), + &mut inst_exports, + &mut type_size, + offset, + )?; + } + ComponentExternalKind::Type => { + insert_export( + export.name, + ComponentEntityType::Type(self.type_at(export.index, false, offset)?), + &mut inst_exports, + &mut type_size, + offset, + )?; + } + } + } + + let ty = Type::ComponentInstance(ComponentInstanceType { + type_size, + kind: ComponentInstanceTypeKind::Exports(inst_exports), + }); + + let id = TypeId { + type_size: ty.type_size(), + index: types.len(), + }; + + types.push(ty); + + Ok(id) + } + + fn instantiate_core_exports( + &mut self, + exports: Vec, + types: &mut TypeList, + offset: usize, + ) -> Result { + fn insert_export( + name: &str, + export: EntityType, + exports: &mut IndexMap, + type_size: &mut usize, + offset: usize, + ) -> Result<()> { + *type_size = combine_type_sizes(*type_size, export.type_size(), offset)?; + + if exports.insert(name.to_string(), export).is_some() { + return Err(BinaryReaderError::new( + format!( + "duplicate instantiation export name `{}` already defined", + name + ), + offset, + )); + } + + Ok(()) + } + + let mut type_size = 1; + let mut inst_exports = IndexMap::new(); + for export in exports { + match export.kind { + ExternalKind::Func => { + insert_export( + export.name, + EntityType::Func(self.core_function_at(export.index, offset)?), + &mut inst_exports, + &mut type_size, + offset, + )?; + } + ExternalKind::Table => insert_export( + export.name, + EntityType::Table(*self.table_at(export.index, offset)?), + &mut inst_exports, + &mut type_size, + offset, + )?, + ExternalKind::Memory => insert_export( + export.name, + EntityType::Memory(*self.memory_at(export.index, offset)?), + &mut inst_exports, + &mut type_size, + offset, + )?, + ExternalKind::Global => { + insert_export( + export.name, + EntityType::Global(*self.global_at(export.index, offset)?), + &mut inst_exports, + &mut type_size, + offset, + )?; + } + ExternalKind::Tag => insert_export( + export.name, + EntityType::Tag(self.core_function_at(export.index, offset)?), + &mut inst_exports, + &mut type_size, + offset, + )?, + } + } + + let ty = Type::Instance(InstanceType { + type_size, + kind: InstanceTypeKind::Exports(inst_exports), + }); + + let id = TypeId { + type_size: ty.type_size(), + index: types.len(), + }; + + types.push(ty); + + Ok(id) + } + + fn alias_core_instance_export( + &mut self, + instance_index: u32, + kind: ExternalKind, + name: &str, + types: &TypeList, + offset: usize, + ) -> Result<()> { + macro_rules! push_module_export { + ($expected:path, $collection:ident, $ty:literal) => {{ + match self.core_instance_export(instance_index, name, types, offset)? { + $expected(ty) => { + self.$collection.push(*ty); + Ok(()) + } + _ => { + return Err(BinaryReaderError::new( + format!( + "export `{}` for core instance {} is not a {}", + name, instance_index, $ty + ), + offset, + )) + } + } + }}; + } + + match kind { + ExternalKind::Func => { + check_max( + self.function_count(), + 1, + MAX_WASM_FUNCTIONS, + "functions", + offset, + )?; + push_module_export!(EntityType::Func, core_funcs, "function") + } + ExternalKind::Table => { + check_max(self.core_tables.len(), 1, MAX_WASM_TABLES, "tables", offset)?; + push_module_export!(EntityType::Table, core_tables, "table") + } + ExternalKind::Memory => { + check_max( + self.core_memories.len(), + 1, + MAX_WASM_MEMORIES, + "memories", + offset, + )?; + push_module_export!(EntityType::Memory, core_memories, "memory") + } + ExternalKind::Global => { + check_max( + self.core_globals.len(), + 1, + MAX_WASM_GLOBALS, + "globals", + offset, + )?; + push_module_export!(EntityType::Global, core_globals, "global") + } + ExternalKind::Tag => { + check_max(self.core_tags.len(), 1, MAX_WASM_TAGS, "tags", offset)?; + push_module_export!(EntityType::Tag, core_tags, "tag") + } + } + } + + fn alias_instance_export( + &mut self, + instance_index: u32, + kind: ComponentExternalKind, + name: &str, + types: &TypeList, + offset: usize, + ) -> Result<()> { + macro_rules! push_component_export { + ($expected:path, $collection:ident, $ty:literal) => {{ + match self.instance_export(instance_index, name, types, offset)? { + $expected(ty) => { + self.$collection.push(*ty); + Ok(()) + } + _ => { + return Err(BinaryReaderError::new( + format!( + "export `{}` for instance {} is not a {}", + name, instance_index, $ty + ), + offset, + )) + } + } + }}; + } + + match kind { + ComponentExternalKind::Module => { + check_max( + self.core_modules.len(), + 1, + MAX_WASM_MODULES, + "modules", + offset, + )?; + push_component_export!(ComponentEntityType::Module, core_modules, "module") + } + ComponentExternalKind::Component => { + check_max( + self.components.len(), + 1, + MAX_WASM_COMPONENTS, + "components", + offset, + )?; + push_component_export!(ComponentEntityType::Component, components, "component") + } + ComponentExternalKind::Instance => { + check_max( + self.instance_count(), + 1, + MAX_WASM_INSTANCES, + "instances", + offset, + )?; + push_component_export!(ComponentEntityType::Instance, instances, "instance") + } + ComponentExternalKind::Func => { + check_max( + self.function_count(), + 1, + MAX_WASM_FUNCTIONS, + "functions", + offset, + )?; + push_component_export!(ComponentEntityType::Func, funcs, "function") + } + ComponentExternalKind::Value => { + check_max(self.values.len(), 1, MAX_WASM_VALUES, "values", offset)?; + match self.instance_export(instance_index, name, types, offset)? { + ComponentEntityType::Value(ty) => { + self.values.push((*ty, false)); + Ok(()) + } + _ => { + return Err(BinaryReaderError::new( + format!( + "export `{}` for instance {} is not a value", + name, instance_index + ), + offset, + )) + } + } + } + ComponentExternalKind::Type => { + check_max(self.type_count(), 1, MAX_WASM_TYPES, "types", offset)?; + push_component_export!(ComponentEntityType::Type, types, "type") + } + } + } + + fn alias_module(components: &mut [Self], count: u32, index: u32, offset: usize) -> Result<()> { + let component = Self::check_alias_count(components, count, offset)?; + let ty = component.module_at(index, offset)?; + + let current = components.last_mut().unwrap(); + check_max( + current.core_modules.len(), + 1, + MAX_WASM_MODULES, + "modules", + offset, + )?; + + current.core_modules.push(ty); + Ok(()) + } + + fn alias_component( + components: &mut [Self], + count: u32, + index: u32, + offset: usize, + ) -> Result<()> { + let component = Self::check_alias_count(components, count, offset)?; + let ty = component.component_at(index, offset)?; + + let current = components.last_mut().unwrap(); + check_max( + current.components.len(), + 1, + MAX_WASM_COMPONENTS, + "components", + offset, + )?; + + current.components.push(ty); + Ok(()) + } + + fn alias_core_type( + components: &mut [Self], + count: u32, + index: u32, + offset: usize, + ) -> Result<()> { + let component = Self::check_alias_count(components, count, offset)?; + let ty = component.type_at(index, true, offset)?; + + let current = components.last_mut().unwrap(); + check_max(current.type_count(), 1, MAX_WASM_TYPES, "types", offset)?; + + current.core_types.push(ty); + Ok(()) + } + + fn alias_type(components: &mut [Self], count: u32, index: u32, offset: usize) -> Result<()> { + let component = Self::check_alias_count(components, count, offset)?; + let ty = component.type_at(index, false, offset)?; + + let current = components.last_mut().unwrap(); + check_max(current.type_count(), 1, MAX_WASM_TYPES, "types", offset)?; + + current.types.push(ty); + Ok(()) + } + + fn check_alias_count(components: &[Self], count: u32, offset: usize) -> Result<&Self> { + let count = count as usize; + if count >= components.len() { + return Err(BinaryReaderError::new( + format!("invalid outer alias count of {}", count), + offset, + )); + } + + Ok(&components[components.len() - count - 1]) + } + + fn create_defined_type( + &self, + ty: crate::ComponentDefinedType, + types: &TypeList, + offset: usize, + ) -> Result { + match ty { + crate::ComponentDefinedType::Primitive(ty) => Ok(ComponentDefinedType::Primitive(ty)), + crate::ComponentDefinedType::Record(fields) => { + self.create_record_type(fields.as_ref(), types, offset) + } + crate::ComponentDefinedType::Variant(cases) => { + self.create_variant_type(cases.as_ref(), types, offset) + } + crate::ComponentDefinedType::List(ty) => Ok(ComponentDefinedType::List( + self.create_component_val_type(ty, types, offset)?, + )), + crate::ComponentDefinedType::Tuple(tys) => { + self.create_tuple_type(tys.as_ref(), types, offset) + } + crate::ComponentDefinedType::Flags(names) => { + self.create_flags_type(names.as_ref(), offset) + } + crate::ComponentDefinedType::Enum(cases) => { + self.create_enum_type(cases.as_ref(), offset) + } + crate::ComponentDefinedType::Union(tys) => { + self.create_union_type(tys.as_ref(), types, offset) + } + crate::ComponentDefinedType::Option(ty) => Ok(ComponentDefinedType::Option( + self.create_component_val_type(ty, types, offset)?, + )), + crate::ComponentDefinedType::Result { ok, err } => Ok(ComponentDefinedType::Result { + ok: ok + .map(|ty| self.create_component_val_type(ty, types, offset)) + .transpose()?, + err: err + .map(|ty| self.create_component_val_type(ty, types, offset)) + .transpose()?, + }), + } + } + + fn create_record_type( + &self, + fields: &[(&str, crate::ComponentValType)], + types: &TypeList, + offset: usize, + ) -> Result { + let mut type_size = 1; + let mut field_map = IndexMap::with_capacity(fields.len()); + + for (name, ty) in fields { + Self::check_name(name, "record field", offset)?; + let ty = self.create_component_val_type(*ty, types, offset)?; + type_size = combine_type_sizes(type_size, ty.type_size(), offset)?; + + if field_map.insert(name.to_string(), ty).is_some() { + return Err(BinaryReaderError::new( + format!("duplicate field named `{}` in record type", name), + offset, + )); + } + } + + Ok(ComponentDefinedType::Record(RecordType { + type_size, + fields: field_map, + })) + } + + fn create_variant_type( + &self, + cases: &[crate::VariantCase], + types: &TypeList, + offset: usize, + ) -> Result { + let mut type_size = 1; + let mut case_map = IndexMap::with_capacity(cases.len()); + + if cases.is_empty() { + return Err(BinaryReaderError::new( + "variant type must have at least one case", + offset, + )); + } + + if cases.len() > u32::MAX as usize { + return Err(BinaryReaderError::new( + "variant type cannot be represented with a 32-bit discriminant value", + offset, + )); + } + + for (i, case) in cases.iter().enumerate() { + Self::check_name(case.name, "variant case", offset)?; + if let Some(refines) = case.refines { + if refines >= i as u32 { + return Err(BinaryReaderError::new( + "variant case can only refine a previously defined case", + offset, + )); + } + } + let ty = case + .ty + .map(|ty| self.create_component_val_type(ty, types, offset)) + .transpose()?; + + type_size = + combine_type_sizes(type_size, ty.map(|ty| ty.type_size()).unwrap_or(1), offset)?; + + if case_map + .insert( + case.name.to_string(), + VariantCase { + ty, + refines: case.refines.map(|i| cases[i as usize].name.to_string()), + }, + ) + .is_some() + { + return Err(BinaryReaderError::new( + format!("duplicate case named `{}` in variant type", case.name), + offset, + )); + } + } + + Ok(ComponentDefinedType::Variant(VariantType { + type_size, + cases: case_map, + })) + } + + fn create_tuple_type( + &self, + tys: &[crate::ComponentValType], + types: &TypeList, + offset: usize, + ) -> Result { + let mut type_size = 1; + let types = tys + .iter() + .map(|ty| { + let ty = self.create_component_val_type(*ty, types, offset)?; + type_size = combine_type_sizes(type_size, ty.type_size(), offset)?; + Ok(ty) + }) + .collect::>()?; + + Ok(ComponentDefinedType::Tuple(TupleType { type_size, types })) + } + + fn create_flags_type(&self, names: &[&str], offset: usize) -> Result { + let mut names_set = IndexSet::with_capacity(names.len()); + + for name in names { + Self::check_name(name, "flag", offset)?; + if !names_set.insert(name.to_string()) { + return Err(BinaryReaderError::new( + format!("duplicate flag named `{}`", name), + offset, + )); + } + } + + Ok(ComponentDefinedType::Flags(names_set)) + } + + fn create_enum_type(&self, cases: &[&str], offset: usize) -> Result { + if cases.len() > u32::MAX as usize { + return Err(BinaryReaderError::new( + "enumeration type cannot be represented with a 32-bit discriminant value", + offset, + )); + } + + let mut tags = IndexSet::with_capacity(cases.len()); + + for tag in cases { + Self::check_name(tag, "enum tag", offset)?; + if !tags.insert(tag.to_string()) { + return Err(BinaryReaderError::new( + format!("duplicate enum tag named `{}`", tag), + offset, + )); + } + } + + Ok(ComponentDefinedType::Enum(tags)) + } + + fn create_union_type( + &self, + tys: &[crate::ComponentValType], + types: &TypeList, + offset: usize, + ) -> Result { + let mut type_size = 1; + let types = tys + .iter() + .map(|ty| { + let ty = self.create_component_val_type(*ty, types, offset)?; + type_size = combine_type_sizes(type_size, ty.type_size(), offset)?; + Ok(ty) + }) + .collect::>()?; + + Ok(ComponentDefinedType::Union(UnionType { type_size, types })) + } + + fn create_component_val_type( + &self, + ty: crate::ComponentValType, + types: &TypeList, + offset: usize, + ) -> Result { + Ok(match ty { + crate::ComponentValType::Primitive(pt) => ComponentValType::Primitive(pt), + crate::ComponentValType::Type(idx) => { + ComponentValType::Type(self.defined_type_at(idx, types, offset)?) + } + }) + } + + pub fn type_at(&self, idx: u32, core: bool, offset: usize) -> Result { + let types = if core { &self.core_types } else { &self.types }; + types.get(idx as usize).copied().ok_or_else(|| { + BinaryReaderError::new( + format!("unknown type {}: type index out of bounds", idx), + offset, + ) + }) + } + + fn function_type_at<'a>( + &self, + idx: u32, + types: &'a TypeList, + offset: usize, + ) -> Result<&'a ComponentFuncType> { + types[self.type_at(idx, false, offset)?] + .as_component_func_type() + .ok_or_else(|| { + BinaryReaderError::new(format!("type index {} is not a function type", idx), offset) + }) + } + + fn function_at(&self, idx: u32, offset: usize) -> Result { + self.funcs.get(idx as usize).copied().ok_or_else(|| { + BinaryReaderError::new( + format!("unknown function {}: function index out of bounds", idx), + offset, + ) + }) + } + + fn component_at(&self, idx: u32, offset: usize) -> Result { + self.components.get(idx as usize).copied().ok_or_else(|| { + BinaryReaderError::new( + format!("unknown component {}: component index out of bounds", idx), + offset, + ) + }) + } + + fn instance_at(&self, idx: u32, offset: usize) -> Result { + self.instances.get(idx as usize).copied().ok_or_else(|| { + BinaryReaderError::new( + format!("unknown instance {}: instance index out of bounds", idx), + offset, + ) + }) + } + + fn instance_export<'a>( + &self, + instance_index: u32, + name: &str, + types: &'a TypeList, + offset: usize, + ) -> Result<&'a ComponentEntityType> { + match types[self.instance_at(instance_index, offset)?] + .as_component_instance_type() + .unwrap() + .internal_exports(types) + .get(name) + { + Some(export) => Ok(export), + None => { + return Err(BinaryReaderError::new( + format!("instance {} has no export named `{}`", instance_index, name), + offset, + )) + } + } + } + + fn value_at(&mut self, idx: u32, offset: usize) -> Result<&ComponentValType> { + match self.values.get_mut(idx as usize) { + Some((ty, used)) if !*used => { + *used = true; + Ok(ty) + } + Some(_) => Err(BinaryReaderError::new( + format!("value {} cannot be used more than once", idx), + offset, + )), + None => Err(BinaryReaderError::new( + format!("unknown value {}: value index out of bounds", idx), + offset, + )), + } + } + + fn defined_type_at(&self, idx: u32, types: &TypeList, offset: usize) -> Result { + let id = self.type_at(idx, false, offset)?; + match &types[id] { + Type::Defined(_) => Ok(id), + _ => Err(BinaryReaderError::new( + format!("type index {} is not a defined type", id.index), + offset, + )), + } + } + + fn core_function_at(&self, idx: u32, offset: usize) -> Result { + match self.core_funcs.get(idx as usize) { + Some(id) => Ok(*id), + None => Err(BinaryReaderError::new( + format!( + "unknown core function {}: function index out of bounds", + idx + ), + offset, + )), + } + } + + fn module_at(&self, idx: u32, offset: usize) -> Result { + match self.core_modules.get(idx as usize) { + Some(id) => Ok(*id), + None => Err(BinaryReaderError::new( + format!("unknown module {}: module index out of bounds", idx), + offset, + )), + } + } + + fn core_instance_at(&self, idx: u32, offset: usize) -> Result { + match self.core_instances.get(idx as usize) { + Some(id) => Ok(*id), + None => Err(BinaryReaderError::new( + format!( + "unknown core instance {}: instance index out of bounds", + idx + ), + offset, + )), + } + } + + fn core_instance_export<'a>( + &self, + instance_index: u32, + name: &str, + types: &'a TypeList, + offset: usize, + ) -> Result<&'a EntityType> { + match types[self.core_instance_at(instance_index, offset)?] + .as_instance_type() + .unwrap() + .internal_exports(types) + .get(name) + { + Some(export) => Ok(export), + None => { + return Err(BinaryReaderError::new( + format!( + "core instance {} has no export named `{}`", + instance_index, name + ), + offset, + )) + } + } + } + + fn global_at(&self, idx: u32, offset: usize) -> Result<&GlobalType> { + match self.core_globals.get(idx as usize) { + Some(t) => Ok(t), + None => Err(BinaryReaderError::new( + format!("unknown global {}: global index out of bounds", idx,), + offset, + )), + } + } + + fn table_at(&self, idx: u32, offset: usize) -> Result<&TableType> { + match self.core_tables.get(idx as usize) { + Some(t) => Ok(t), + None => Err(BinaryReaderError::new( + format!("unknown table {}: table index out of bounds", idx), + offset, + )), + } + } + + fn memory_at(&self, idx: u32, offset: usize) -> Result<&MemoryType> { + match self.core_memories.get(idx as usize) { + Some(t) => Ok(t), + None => Err(BinaryReaderError::new( + format!("unknown memory {}: memory index out of bounds", idx,), + offset, + )), + } + } +} + +impl Default for ComponentState { + fn default() -> Self { + Self { + core_types: Default::default(), + core_modules: Default::default(), + core_instances: Default::default(), + core_funcs: Default::default(), + core_memories: Default::default(), + core_tables: Default::default(), + core_globals: Default::default(), + core_tags: Default::default(), + types: Default::default(), + funcs: Default::default(), + values: Default::default(), + instances: Default::default(), + components: Default::default(), + imports: Default::default(), + exports: Default::default(), + has_start: Default::default(), + type_size: 1, + } + } +} diff --git a/crates/wasmparser/src/validator/core.rs b/crates/wasmparser/src/validator/core.rs new file mode 100644 index 000000000..49d4dae8f --- /dev/null +++ b/crates/wasmparser/src/validator/core.rs @@ -0,0 +1,1016 @@ +//! State relating to validating a WebAssembly module. +//! +use super::{ + check_max, combine_type_sizes, + operators::OperatorValidator, + types::{EntityType, Type, TypeId, TypeList}, +}; +use crate::{ + limits::*, BinaryReaderError, ConstExpr, Data, DataKind, Element, ElementItem, ElementKind, + ExternalKind, FuncType, Global, GlobalType, MemoryType, Operator, Result, TableType, TagType, + TypeRef, ValType, VisitOperator, WasmFeatures, WasmModuleResources, +}; +use indexmap::IndexMap; +use std::{collections::HashSet, sync::Arc}; + +fn check_value_type(ty: ValType, features: &WasmFeatures, offset: usize) -> Result<()> { + match features.check_value_type(ty) { + Ok(()) => Ok(()), + Err(e) => Err(BinaryReaderError::new(e, offset)), + } +} + +// Section order for WebAssembly modules. +// +// Component sections are unordered and allow for duplicates, +// so this isn't used for components. +#[derive(Copy, Clone, PartialOrd, Ord, PartialEq, Eq, Debug)] +pub enum Order { + Initial, + Type, + Import, + Function, + Table, + Memory, + Tag, + Global, + Export, + Start, + Element, + DataCount, + Code, + Data, +} + +impl Default for Order { + fn default() -> Order { + Order::Initial + } +} + +#[derive(Default)] +pub(crate) struct ModuleState { + /// Internal state that is incrementally built-up for the module being + /// validated. This houses type information for all wasm items, like + /// functions. Note that this starts out as a solely owned `Arc` so we can + /// get mutable access, but after we get to the code section this is never + /// mutated to we can clone it cheaply and hand it to sub-validators. + pub module: arc::MaybeOwned, + + /// Where we are, order-wise, in the wasm binary. + order: Order, + + /// The number of data segments in the data section (if present). + pub data_segment_count: u32, + + /// The number of functions we expect to be defined in the code section, or + /// basically the length of the function section if it was found. The next + /// index is where we are, in the code section index space, for the next + /// entry in the code section (used to figure out what type is next for the + /// function being validated). + pub expected_code_bodies: Option, + + /// When parsing the code section, represents the current index in the section. + code_section_index: Option, +} + +impl ModuleState { + pub fn update_order(&mut self, order: Order, offset: usize) -> Result<()> { + if self.order >= order { + return Err(BinaryReaderError::new("section out of order", offset)); + } + + self.order = order; + + Ok(()) + } + + pub fn validate_end(&self, offset: usize) -> Result<()> { + // Ensure that the data count section, if any, was correct. + if let Some(data_count) = self.module.data_count { + if data_count != self.data_segment_count { + return Err(BinaryReaderError::new( + "data count and data section have inconsistent lengths", + offset, + )); + } + } + // Ensure that the function section, if nonzero, was paired with a code + // section with the appropriate length. + if let Some(n) = self.expected_code_bodies { + if n > 0 { + return Err(BinaryReaderError::new( + "function and code section have inconsistent lengths", + offset, + )); + } + } + + Ok(()) + } + + pub fn next_code_index_and_type(&mut self, offset: usize) -> Result<(u32, u32)> { + let index = self + .code_section_index + .get_or_insert(self.module.num_imported_functions as usize); + + if *index >= self.module.functions.len() { + return Err(BinaryReaderError::new( + "code section entry exceeds number of functions", + offset, + )); + } + + let ty = self.module.functions[*index]; + *index += 1; + + Ok(((*index - 1) as u32, ty)) + } + + pub fn add_global( + &mut self, + global: Global, + features: &WasmFeatures, + types: &TypeList, + offset: usize, + ) -> Result<()> { + self.module + .check_global_type(&global.ty, features, offset)?; + self.check_const_expr(&global.init_expr, global.ty.content_type, features, types)?; + self.module.assert_mut().globals.push(global.ty); + Ok(()) + } + + pub fn add_data_segment( + &mut self, + data: Data, + features: &WasmFeatures, + types: &TypeList, + offset: usize, + ) -> Result<()> { + match data.kind { + DataKind::Passive => Ok(()), + DataKind::Active { + memory_index, + offset_expr, + } => { + let ty = self.module.memory_at(memory_index, offset)?.index_type(); + self.check_const_expr(&offset_expr, ty, features, types) + } + } + } + + pub fn add_element_segment( + &mut self, + e: Element, + features: &WasmFeatures, + types: &TypeList, + offset: usize, + ) -> Result<()> { + // the `funcref` value type is allowed all the way back to the MVP, so + // don't check it here + if e.ty != ValType::FuncRef { + check_value_type(e.ty, features, offset)?; + } + if !e.ty.is_reference_type() { + return Err(BinaryReaderError::new("malformed reference type", offset)); + } + match e.kind { + ElementKind::Active { + table_index, + offset_expr, + } => { + let table = self.module.table_at(table_index, offset)?; + if e.ty != table.element_type { + return Err(BinaryReaderError::new( + "invalid element type for table type", + offset, + )); + } + + self.check_const_expr(&offset_expr, ValType::I32, features, types)?; + } + ElementKind::Passive | ElementKind::Declared => { + if !features.bulk_memory { + return Err(BinaryReaderError::new( + "bulk memory must be enabled", + offset, + )); + } + } + } + let mut items = e.items.get_items_reader()?; + if items.get_count() > MAX_WASM_TABLE_ENTRIES as u32 { + return Err(BinaryReaderError::new( + "number of elements is out of bounds", + offset, + )); + } + for _ in 0..items.get_count() { + let offset = items.original_position(); + match items.read()? { + ElementItem::Expr(expr) => { + self.check_const_expr(&expr, e.ty, features, types)?; + } + ElementItem::Func(f) => { + if e.ty != ValType::FuncRef { + return Err(BinaryReaderError::new( + "type mismatch: segment does not have funcref type", + offset, + )); + } + self.module.get_func_type(f, types, offset)?; + self.module.assert_mut().function_references.insert(f); + } + } + } + + self.module.assert_mut().element_types.push(e.ty); + Ok(()) + } + + fn check_const_expr( + &mut self, + expr: &ConstExpr<'_>, + expected_ty: ValType, + features: &WasmFeatures, + types: &TypeList, + ) -> Result<()> { + let mut ops = expr.get_operators_reader(); + let mut validator = OperatorValidator::new_const_expr(features, expected_ty); + let mut uninserted_funcref = false; + + while !ops.eof() { + let offset = ops.original_position(); + let op = ops.read()?; + match &op { + // These are always valid in const expressions. + Operator::I32Const { .. } + | Operator::I64Const { .. } + | Operator::F32Const { .. } + | Operator::F64Const { .. } + | Operator::RefNull { .. } + | Operator::V128Const { .. } + | Operator::End => {} + + // These are valid const expressions when the extended-const proposal is enabled. + Operator::I32Add + | Operator::I32Sub + | Operator::I32Mul + | Operator::I64Add + | Operator::I64Sub + | Operator::I64Mul + if features.extended_const => {} + + // `global.get` is a valid const expression for imported, immutable globals. + Operator::GlobalGet { global_index } => { + let global = self.module.global_at(*global_index, offset)?; + if *global_index >= self.module.num_imported_globals { + return Err(BinaryReaderError::new( + "constant expression required: global.get of locally defined global", + offset, + )); + } + if global.mutable { + return Err(BinaryReaderError::new( + "constant expression required: global.get of mutable global", + offset, + )); + } + } + + // Functions in initialization expressions are only valid in + // element segment initialization expressions and globals. In + // these contexts we want to record all function references. + // + // Initialization expressions can also be found in the data + // section, however. A `RefFunc` instruction in those situations + // is always invalid and needs to produce a validation error. In + // this situation, though, we can no longer modify + // the state since it's been "snapshot" already for + // parallel validation of functions. + // + // If we cannot modify the function references then this function + // *should* result in a validation error, but we defer that + // validation error to happen later. The `uninserted_funcref` + // boolean here is used to track this and will cause a panic + // (aka a fuzz bug) if we somehow forget to emit an error somewhere + // else. + Operator::RefFunc { function_index } => { + if self.order == Order::Data { + uninserted_funcref = true; + } else { + self.module + .assert_mut() + .function_references + .insert(*function_index); + } + } + _ => { + return Err(BinaryReaderError::new( + "constant expression required: non-constant operator", + offset, + )); + } + } + + let resources = OperatorValidatorResources { + module: &self.module, + types, + }; + validator + .with_resources(&resources) + .visit_operator(offset, &op)?; + } + + validator.finish(ops.original_position())?; + + // See comment in `RefFunc` above for why this is an assert. + assert!(!uninserted_funcref); + + Ok(()) + } +} + +pub(crate) struct Module { + // This is set once the code section starts. + // `WasmModuleResources` implementations use the snapshot to + // enable parallel validation of functions. + pub snapshot: Option>, + // Stores indexes into the validator's types list. + pub types: Vec, + pub tables: Vec, + pub memories: Vec, + pub globals: Vec, + pub element_types: Vec, + pub data_count: Option, + // Stores indexes into `types`. + pub functions: Vec, + pub tags: Vec, + pub function_references: HashSet, + pub imports: IndexMap<(String, String), Vec>, + pub exports: IndexMap, + pub type_size: usize, + num_imported_globals: u32, + num_imported_functions: u32, +} + +impl Module { + pub fn add_type( + &mut self, + ty: crate::Type, + features: &WasmFeatures, + types: &mut TypeList, + offset: usize, + check_limit: bool, + ) -> Result<()> { + let ty = match ty { + crate::Type::Func(t) => { + for ty in t.params.iter().chain(t.returns.iter()) { + check_value_type(*ty, features, offset)?; + } + if t.returns.len() > 1 && !features.multi_value { + return Err(BinaryReaderError::new( + "func type returns multiple values but the multi-value feature is not enabled", + offset, + )); + } + Type::Func(t) + } + }; + + if check_limit { + check_max(self.types.len(), 1, MAX_WASM_TYPES, "types", offset)?; + } + + self.types.push(TypeId { + type_size: ty.type_size(), + index: types.len(), + }); + types.push(ty); + Ok(()) + } + + pub fn add_import( + &mut self, + import: crate::Import, + features: &WasmFeatures, + types: &TypeList, + offset: usize, + ) -> Result<()> { + let entity = self.check_type_ref(&import.ty, features, types, offset)?; + + let (len, max, desc) = match import.ty { + TypeRef::Func(type_index) => { + self.functions.push(type_index); + self.num_imported_functions += 1; + (self.functions.len(), MAX_WASM_FUNCTIONS, "functions") + } + TypeRef::Table(ty) => { + self.tables.push(ty); + (self.tables.len(), self.max_tables(features), "tables") + } + TypeRef::Memory(ty) => { + self.memories.push(ty); + (self.memories.len(), self.max_memories(features), "memories") + } + TypeRef::Tag(ty) => { + self.tags.push(self.types[ty.func_type_idx as usize]); + (self.tags.len(), MAX_WASM_TAGS, "tags") + } + TypeRef::Global(ty) => { + if !features.mutable_global && ty.mutable { + return Err(BinaryReaderError::new( + "mutable global support is not enabled", + offset, + )); + } + self.globals.push(ty); + self.num_imported_globals += 1; + (self.globals.len(), MAX_WASM_GLOBALS, "globals") + } + }; + + check_max(len, 0, max, desc, offset)?; + + self.type_size = combine_type_sizes(self.type_size, entity.type_size(), offset)?; + + self.imports + .entry((import.module.to_string(), import.name.to_string())) + .or_default() + .push(entity); + + Ok(()) + } + + pub fn add_export( + &mut self, + name: &str, + ty: EntityType, + features: &WasmFeatures, + offset: usize, + check_limit: bool, + ) -> Result<()> { + if !features.mutable_global { + if let EntityType::Global(global_type) = ty { + if global_type.mutable { + return Err(BinaryReaderError::new( + "mutable global support is not enabled", + offset, + )); + } + } + } + + if check_limit { + check_max(self.exports.len(), 1, MAX_WASM_EXPORTS, "exports", offset)?; + } + + self.type_size = combine_type_sizes(self.type_size, ty.type_size(), offset)?; + + match self.exports.insert(name.to_string(), ty) { + Some(_) => Err(BinaryReaderError::new( + format!("duplicate export name `{}` already defined", name), + offset, + )), + None => Ok(()), + } + } + + pub fn add_function(&mut self, type_index: u32, types: &TypeList, offset: usize) -> Result<()> { + self.func_type_at(type_index, types, offset)?; + self.functions.push(type_index); + Ok(()) + } + + pub fn add_table( + &mut self, + ty: TableType, + features: &WasmFeatures, + offset: usize, + ) -> Result<()> { + self.check_table_type(&ty, features, offset)?; + self.tables.push(ty); + Ok(()) + } + + pub fn add_memory( + &mut self, + ty: MemoryType, + features: &WasmFeatures, + offset: usize, + ) -> Result<()> { + self.check_memory_type(&ty, features, offset)?; + self.memories.push(ty); + Ok(()) + } + + pub fn add_tag( + &mut self, + ty: TagType, + features: &WasmFeatures, + types: &TypeList, + offset: usize, + ) -> Result<()> { + self.check_tag_type(&ty, features, types, offset)?; + self.tags.push(self.types[ty.func_type_idx as usize]); + Ok(()) + } + + pub fn type_at(&self, idx: u32, offset: usize) -> Result { + self.types.get(idx as usize).copied().ok_or_else(|| { + BinaryReaderError::new( + format!("unknown type {}: type index out of bounds", idx), + offset, + ) + }) + } + + fn func_type_at<'a>( + &self, + type_index: u32, + types: &'a TypeList, + offset: usize, + ) -> Result<&'a FuncType> { + types[self.type_at(type_index, offset)?] + .as_func_type() + .ok_or_else(|| { + BinaryReaderError::new( + format!("type index {} is not a function type", type_index), + offset, + ) + }) + } + + pub fn check_type_ref( + &self, + type_ref: &TypeRef, + features: &WasmFeatures, + types: &TypeList, + offset: usize, + ) -> Result { + Ok(match type_ref { + TypeRef::Func(type_index) => { + self.func_type_at(*type_index, types, offset)?; + EntityType::Func(self.types[*type_index as usize]) + } + TypeRef::Table(t) => { + self.check_table_type(t, features, offset)?; + EntityType::Table(*t) + } + TypeRef::Memory(t) => { + self.check_memory_type(t, features, offset)?; + EntityType::Memory(*t) + } + TypeRef::Tag(t) => { + self.check_tag_type(t, features, types, offset)?; + EntityType::Tag(self.types[t.func_type_idx as usize]) + } + TypeRef::Global(t) => { + self.check_global_type(t, features, offset)?; + EntityType::Global(*t) + } + }) + } + + fn check_table_type( + &self, + ty: &TableType, + features: &WasmFeatures, + offset: usize, + ) -> Result<()> { + // the `funcref` value type is allowed all the way back to the MVP, so + // don't check it here + if ty.element_type != ValType::FuncRef { + check_value_type(ty.element_type, features, offset)?; + } + + if !ty.element_type.is_reference_type() { + return Err(BinaryReaderError::new( + "element is not reference type", + offset, + )); + } + self.check_limits(ty.initial, ty.maximum, offset)?; + if ty.initial > MAX_WASM_TABLE_ENTRIES as u32 { + return Err(BinaryReaderError::new( + "minimum table size is out of bounds", + offset, + )); + } + Ok(()) + } + + fn check_memory_type( + &self, + ty: &MemoryType, + features: &WasmFeatures, + offset: usize, + ) -> Result<()> { + self.check_limits(ty.initial, ty.maximum, offset)?; + let (true_maximum, err) = if ty.memory64 { + if !features.memory64 { + return Err(BinaryReaderError::new( + "memory64 must be enabled for 64-bit memories", + offset, + )); + } + ( + MAX_WASM_MEMORY64_PAGES, + "memory size must be at most 2**48 pages", + ) + } else { + ( + MAX_WASM_MEMORY32_PAGES, + "memory size must be at most 65536 pages (4GiB)", + ) + }; + if ty.initial > true_maximum { + return Err(BinaryReaderError::new(err, offset)); + } + if let Some(maximum) = ty.maximum { + if maximum > true_maximum { + return Err(BinaryReaderError::new(err, offset)); + } + } + if ty.shared { + if !features.threads { + return Err(BinaryReaderError::new( + "threads must be enabled for shared memories", + offset, + )); + } + if ty.maximum.is_none() { + return Err(BinaryReaderError::new( + "shared memory must have maximum size", + offset, + )); + } + } + Ok(()) + } + + pub(crate) fn imports_for_module_type( + &self, + offset: usize, + ) -> Result> { + // Ensure imports are unique, which is a requirement of the component model + self.imports.iter().map(|((module, name), types)| { + if types.len() != 1 { + return Err(BinaryReaderError::new( + format!( + "module has a duplicate import name `{}:{}` that is not allowed in components", + module, name + ), + offset, + )); + } + Ok(((module.clone(), name.clone()), types[0])) + }).collect::>() + } + + fn check_tag_type( + &self, + ty: &TagType, + features: &WasmFeatures, + types: &TypeList, + offset: usize, + ) -> Result<()> { + if !features.exceptions { + return Err(BinaryReaderError::new( + "exceptions proposal not enabled", + offset, + )); + } + let ty = self.func_type_at(ty.func_type_idx, types, offset)?; + if ty.returns.len() > 0 { + return Err(BinaryReaderError::new( + "invalid exception type: non-empty tag result type", + offset, + )); + } + Ok(()) + } + + fn check_global_type( + &self, + ty: &GlobalType, + features: &WasmFeatures, + offset: usize, + ) -> Result<()> { + check_value_type(ty.content_type, features, offset) + } + + fn check_limits(&self, initial: T, maximum: Option, offset: usize) -> Result<()> + where + T: Into, + { + if let Some(max) = maximum { + if initial.into() > max.into() { + return Err(BinaryReaderError::new( + "size minimum must not be greater than maximum", + offset, + )); + } + } + Ok(()) + } + + pub fn max_tables(&self, features: &WasmFeatures) -> usize { + if features.reference_types { + MAX_WASM_TABLES + } else { + 1 + } + } + + pub fn max_memories(&self, features: &WasmFeatures) -> usize { + if features.multi_memory { + MAX_WASM_MEMORIES + } else { + 1 + } + } + + pub fn export_to_entity_type( + &mut self, + export: &crate::Export, + offset: usize, + ) -> Result { + let check = |ty: &str, index: u32, total: usize| { + if index as usize >= total { + Err(BinaryReaderError::new( + format!( + "unknown {ty} {index}: exported {ty} index out of bounds", + index = index, + ty = ty, + ), + offset, + )) + } else { + Ok(()) + } + }; + + Ok(match export.kind { + ExternalKind::Func => { + check("function", export.index, self.functions.len())?; + self.function_references.insert(export.index); + EntityType::Func(self.types[self.functions[export.index as usize] as usize]) + } + ExternalKind::Table => { + check("table", export.index, self.tables.len())?; + EntityType::Table(self.tables[export.index as usize]) + } + ExternalKind::Memory => { + check("memory", export.index, self.memories.len())?; + EntityType::Memory(self.memories[export.index as usize]) + } + ExternalKind::Global => { + check("global", export.index, self.globals.len())?; + EntityType::Global(self.globals[export.index as usize]) + } + ExternalKind::Tag => { + check("tag", export.index, self.tags.len())?; + EntityType::Tag(self.tags[export.index as usize]) + } + }) + } + + pub fn get_func_type<'a>( + &self, + func_idx: u32, + types: &'a TypeList, + offset: usize, + ) -> Result<&'a FuncType> { + match self.functions.get(func_idx as usize) { + Some(idx) => self.func_type_at(*idx, types, offset), + None => Err(BinaryReaderError::new( + format!("unknown function {}: func index out of bounds", func_idx), + offset, + )), + } + } + + fn global_at(&self, idx: u32, offset: usize) -> Result<&GlobalType> { + match self.globals.get(idx as usize) { + Some(t) => Ok(t), + None => Err(BinaryReaderError::new( + format!("unknown global {}: global index out of bounds", idx,), + offset, + )), + } + } + + fn table_at(&self, idx: u32, offset: usize) -> Result<&TableType> { + match self.tables.get(idx as usize) { + Some(t) => Ok(t), + None => Err(BinaryReaderError::new( + format!("unknown table {}: table index out of bounds", idx), + offset, + )), + } + } + + fn memory_at(&self, idx: u32, offset: usize) -> Result<&MemoryType> { + match self.memories.get(idx as usize) { + Some(t) => Ok(t), + None => Err(BinaryReaderError::new( + format!("unknown memory {}: memory index out of bounds", idx,), + offset, + )), + } + } +} + +impl Default for Module { + fn default() -> Self { + Self { + snapshot: Default::default(), + types: Default::default(), + tables: Default::default(), + memories: Default::default(), + globals: Default::default(), + element_types: Default::default(), + data_count: Default::default(), + functions: Default::default(), + tags: Default::default(), + function_references: Default::default(), + imports: Default::default(), + exports: Default::default(), + type_size: 1, + num_imported_globals: Default::default(), + num_imported_functions: Default::default(), + } + } +} + +struct OperatorValidatorResources<'a> { + module: &'a Module, + types: &'a TypeList, +} + +impl WasmModuleResources for OperatorValidatorResources<'_> { + type FuncType = crate::FuncType; + + fn table_at(&self, at: u32) -> Option { + self.module.tables.get(at as usize).cloned() + } + + fn memory_at(&self, at: u32) -> Option { + self.module.memories.get(at as usize).cloned() + } + + fn tag_at(&self, at: u32) -> Option<&Self::FuncType> { + Some( + self.types[*self.module.tags.get(at as usize)?] + .as_func_type() + .unwrap(), + ) + } + + fn global_at(&self, at: u32) -> Option { + self.module.globals.get(at as usize).cloned() + } + + fn func_type_at(&self, at: u32) -> Option<&Self::FuncType> { + Some( + self.types[*self.module.types.get(at as usize)?] + .as_func_type() + .unwrap(), + ) + } + + fn type_of_function(&self, at: u32) -> Option<&Self::FuncType> { + self.func_type_at(*self.module.functions.get(at as usize)?) + } + + fn element_type_at(&self, at: u32) -> Option { + self.module.element_types.get(at as usize).cloned() + } + + fn element_count(&self) -> u32 { + self.module.element_types.len() as u32 + } + + fn data_count(&self) -> Option { + self.module.data_count + } + + fn is_function_referenced(&self, idx: u32) -> bool { + self.module.function_references.contains(&idx) + } +} + +/// The implementation of [`WasmModuleResources`] used by +/// [`Validator`](crate::Validator). +pub struct ValidatorResources(pub(crate) Arc); + +impl WasmModuleResources for ValidatorResources { + type FuncType = crate::FuncType; + + fn table_at(&self, at: u32) -> Option { + self.0.tables.get(at as usize).cloned() + } + + fn memory_at(&self, at: u32) -> Option { + self.0.memories.get(at as usize).cloned() + } + + fn tag_at(&self, at: u32) -> Option<&Self::FuncType> { + Some( + self.0.snapshot.as_ref().unwrap()[*self.0.tags.get(at as usize)?] + .as_func_type() + .unwrap(), + ) + } + + fn global_at(&self, at: u32) -> Option { + self.0.globals.get(at as usize).cloned() + } + + fn func_type_at(&self, at: u32) -> Option<&Self::FuncType> { + Some( + self.0.snapshot.as_ref().unwrap()[*self.0.types.get(at as usize)?] + .as_func_type() + .unwrap(), + ) + } + + fn type_of_function(&self, at: u32) -> Option<&Self::FuncType> { + self.func_type_at(*self.0.functions.get(at as usize)?) + } + + fn element_type_at(&self, at: u32) -> Option { + self.0.element_types.get(at as usize).cloned() + } + + fn element_count(&self) -> u32 { + self.0.element_types.len() as u32 + } + + fn data_count(&self) -> Option { + self.0.data_count + } + + fn is_function_referenced(&self, idx: u32) -> bool { + self.0.function_references.contains(&idx) + } +} + +const _: () = { + fn assert_send() {} + + // Assert that `ValidatorResources` is Send so function validation + // can be parallelizable + fn assert() { + assert_send::(); + } +}; + +mod arc { + use std::ops::Deref; + use std::sync::Arc; + + pub struct MaybeOwned { + owned: bool, + arc: Arc, + } + + impl MaybeOwned { + #[allow(clippy::cast_ref_to_mut)] + fn as_mut(&mut self) -> Option<&mut T> { + if !self.owned { + return None; + } + debug_assert!(Arc::get_mut(&mut self.arc).is_some()); + Some(unsafe { &mut *(Arc::as_ptr(&self.arc) as *mut T) }) + } + + pub fn assert_mut(&mut self) -> &mut T { + self.as_mut().unwrap() + } + + pub fn arc(&mut self) -> &Arc { + self.owned = false; + &self.arc + } + } + + impl Default for MaybeOwned { + fn default() -> MaybeOwned { + MaybeOwned { + owned: true, + arc: Arc::default(), + } + } + } + + impl Deref for MaybeOwned { + type Target = T; + + fn deref(&self) -> &T { + &self.arc + } + } +} diff --git a/crates/wasmparser/src/validator/func.rs b/crates/wasmparser/src/validator/func.rs new file mode 100644 index 000000000..1e7c18a74 --- /dev/null +++ b/crates/wasmparser/src/validator/func.rs @@ -0,0 +1,760 @@ +use super::operators::OperatorValidator; +use crate::{BinaryReader, Result, ValType}; +use crate::{FunctionBody, Operator, WasmFeatures, WasmModuleResources}; + +/// Validation context for a WebAssembly function. +/// +/// This structure is created by +/// [`Validator::code_section_entry`](crate::Validator::code_section_entry) +/// and is created per-function in a WebAssembly module. This structure is +/// suitable for sending to other threads while the original +/// [`Validator`](crate::Validator) continues processing other functions. +pub struct FuncValidator { + validator: OperatorValidator, + resources: T, + index: u32, +} + +impl FuncValidator { + /// Creates a new `FuncValidator`. + /// + /// The returned `FuncValidator` can be used to validate a function with + /// the type `ty` specified. The `resources` indicate what the containing + /// module has for the function to use, and the `features` configure what + /// WebAssembly proposals are enabled for this function. + /// + /// The returned validator can be used to then parse a [`FunctionBody`], for + /// example, to read locals and validate operators. + pub fn new( + index: u32, + ty: u32, + offset: usize, + resources: T, + features: &WasmFeatures, + ) -> Result> { + Ok(FuncValidator { + validator: OperatorValidator::new_func(ty, offset, features, &resources)?, + resources, + index, + }) + } + + /// Get the current height of the operand stack. + /// + /// This returns the height of the whole operand stack for this function, + /// not just for the current control frame. + pub fn operand_stack_height(&self) -> u32 { + self.validator.operand_stack_height() as u32 + } + + /// Convenience function to validate an entire function's body. + /// + /// You may not end up using this in final implementations because you'll + /// often want to interleave validation with parsing. + pub fn validate(&mut self, body: &FunctionBody<'_>) -> Result<()> { + let mut reader = body.get_binary_reader(); + self.read_locals(&mut reader)?; + reader.allow_memarg64(self.validator.features.memory64); + while !reader.eof() { + reader.visit_operator(self)??; + } + self.finish(reader.original_position()) + } + + /// Reads the local defintions from the given `BinaryReader`, often sourced + /// from a `FunctionBody`. + /// + /// This function will automatically advance the `BinaryReader` forward, + /// leaving reading operators up to the caller afterwards. + pub fn read_locals(&mut self, reader: &mut BinaryReader<'_>) -> Result<()> { + for _ in 0..reader.read_var_u32()? { + let offset = reader.original_position(); + let cnt = reader.read_var_u32()?; + let ty = reader.read_val_type()?; + self.define_locals(offset, cnt, ty)?; + } + Ok(()) + } + + /// Defines locals into this validator. + /// + /// This should be used if the application is already reading local + /// definitions and there's no need to re-parse the function again. + pub fn define_locals(&mut self, offset: usize, count: u32, ty: ValType) -> Result<()> { + self.validator.define_locals(offset, count, ty) + } + + /// Validates the next operator in a function. + /// + /// This functions is expected to be called once-per-operator in a + /// WebAssembly function. Each operator's offset in the original binary and + /// the operator itself are passed to this function to provide more useful + /// error messages. + pub fn op(&mut self, offset: usize, operator: &Operator<'_>) -> Result<()> { + self.validator + .with_resources(&self.resources) + .visit_operator(offset, operator) + } + + /// Function that must be called after the last opcode has been processed. + /// + /// This will validate that the function was properly terminated with the + /// `end` opcode. If this function is not called then the function will not + /// be properly validated. + /// + /// The `offset` provided to this function will be used as a position for an + /// error if validation fails. + pub fn finish(&mut self, offset: usize) -> Result<()> { + self.validator.finish(offset) + } + + /// Returns the underlying module resources that this validator is using. + pub fn resources(&self) -> &T { + &self.resources + } + + /// The index of the function within the module's function index space that + /// is being validated. + pub fn index(&self) -> u32 { + self.index + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::WasmFuncType; + + struct EmptyResources; + + impl WasmModuleResources for EmptyResources { + type FuncType = EmptyFuncType; + + fn table_at(&self, _at: u32) -> Option { + todo!() + } + fn memory_at(&self, _at: u32) -> Option { + todo!() + } + fn tag_at(&self, _at: u32) -> Option<&Self::FuncType> { + todo!() + } + fn global_at(&self, _at: u32) -> Option { + todo!() + } + fn func_type_at(&self, _type_idx: u32) -> Option<&Self::FuncType> { + Some(&EmptyFuncType) + } + fn type_of_function(&self, _func_idx: u32) -> Option<&Self::FuncType> { + todo!() + } + fn element_type_at(&self, _at: u32) -> Option { + todo!() + } + fn element_count(&self) -> u32 { + todo!() + } + fn data_count(&self) -> Option { + todo!() + } + fn is_function_referenced(&self, _idx: u32) -> bool { + todo!() + } + } + + struct EmptyFuncType; + + impl WasmFuncType for EmptyFuncType { + fn len_inputs(&self) -> usize { + 0 + } + fn len_outputs(&self) -> usize { + 0 + } + fn input_at(&self, _at: u32) -> Option { + todo!() + } + fn output_at(&self, _at: u32) -> Option { + todo!() + } + } + + #[test] + fn operand_stack_height() { + let mut v = FuncValidator::new(0, 0, 0, &EmptyResources, &Default::default()).unwrap(); + + // Initially zero values on the stack. + assert_eq!(v.operand_stack_height(), 0); + + // Pushing a constant value makes use have one value on the stack. + assert!(v.op(0, &Operator::I32Const { value: 0 }).is_ok()); + assert_eq!(v.operand_stack_height(), 1); + + // Entering a new control block does not affect the stack height. + assert!(v + .op( + 1, + &Operator::Block { + ty: crate::BlockType::Empty + } + ) + .is_ok()); + assert_eq!(v.operand_stack_height(), 1); + + // Pushing another constant value makes use have two values on the stack. + assert!(v.op(2, &Operator::I32Const { value: 99 }).is_ok()); + assert_eq!(v.operand_stack_height(), 2); + } +} + +use crate::{ + BlockType, BrTable, Ieee32, Ieee64, MemoryImmediate, SIMDLaneIndex, VisitOperator, V128, +}; + +macro_rules! forward { + ( $this:ident.$visit_fn:ident($offset:expr $(, $param:expr)*) $(,)? ) => {{ + $this.validator.with_resources(&$this.resources).$visit_fn($offset, $( $param ),*) + }}; +} + +#[allow(unused_variables)] +#[rustfmt::skip] +impl<'a, T> VisitOperator<'a> for FuncValidator +where + T: WasmModuleResources, +{ + type Output = Result<()>; + + fn visit_nop(&mut self, offset: usize) -> Self::Output { forward!(self.visit_nop(offset)) } + fn visit_unreachable(&mut self, offset: usize) -> Self::Output { forward!(self.visit_unreachable(offset)) } + fn visit_block(&mut self, offset: usize, ty: BlockType) -> Self::Output { forward!(self.visit_block(offset, ty)) } + fn visit_loop(&mut self, offset: usize, ty: BlockType) -> Self::Output { forward!(self.visit_loop(offset, ty)) } + fn visit_if(&mut self, offset: usize, ty: BlockType) -> Self::Output { forward!(self.visit_if(offset, ty)) } + fn visit_else(&mut self, offset: usize) -> Self::Output { forward!(self.visit_else(offset)) } + fn visit_try(&mut self, offset: usize, ty: BlockType) -> Self::Output { forward!(self.visit_try(offset, ty)) } + fn visit_catch(&mut self, offset: usize, index: u32) -> Self::Output { forward!(self.visit_catch(offset, index)) } + fn visit_throw(&mut self, offset: usize, index: u32) -> Self::Output { forward!(self.visit_throw(offset, index)) } + fn visit_rethrow(&mut self, offset: usize, relative_depth: u32) -> Self::Output { forward!(self.visit_rethrow(offset, relative_depth)) } + fn visit_delegate(&mut self, offset: usize, relative_depth: u32) -> Self::Output { forward!(self.visit_delegate(offset, relative_depth)) } + fn visit_catch_all(&mut self, offset: usize) -> Self::Output { forward!(self.visit_catch_all(offset)) } + fn visit_end(&mut self, offset: usize) -> Self::Output { forward!(self.visit_end(offset)) } + fn visit_br(&mut self, offset: usize, relative_depth: u32) -> Self::Output { forward!(self.visit_br(offset, relative_depth)) } + fn visit_br_if(&mut self, offset: usize, relative_depth: u32) -> Self::Output { forward!(self.visit_br_if(offset, relative_depth)) } + fn visit_br_table(&mut self, offset: usize, table: &BrTable) -> Self::Output { forward!(self.visit_br_table(offset, table)) } + fn visit_return(&mut self, offset: usize) -> Self::Output { forward!(self.visit_return(offset)) } + fn visit_call(&mut self, offset: usize, function_index: u32) -> Self::Output { forward!(self.visit_call(offset, function_index)) } + fn visit_return_call(&mut self, offset: usize, function_index: u32) -> Self::Output { forward!(self.visit_return_call(offset, function_index)) } + fn visit_call_indirect(&mut self, offset: usize, index: u32, table_index: u32, table_byte: u8) -> Self::Output { forward!(self.visit_call_indirect(offset, index, table_index, table_byte)) } + fn visit_return_call_indirect(&mut self, offset: usize, index: u32, table_index: u32) -> Self::Output { forward!(self.visit_return_call_indirect(offset, index, table_index)) } + fn visit_drop(&mut self, offset: usize) -> Self::Output { forward!(self.visit_drop(offset)) } + fn visit_select(&mut self, offset: usize) -> Self::Output { forward!(self.visit_select(offset)) } + fn visit_typed_select(&mut self, offset: usize, ty: ValType) -> Self::Output { forward!(self.visit_typed_select(offset, ty)) } + fn visit_local_get(&mut self, offset: usize, local_index: u32) -> Self::Output { forward!(self.visit_local_get(offset, local_index)) } + fn visit_local_set(&mut self, offset: usize, local_index: u32) -> Self::Output { forward!(self.visit_local_set(offset, local_index)) } + fn visit_local_tee(&mut self, offset: usize, local_index: u32) -> Self::Output { forward!(self.visit_local_tee(offset, local_index)) } + fn visit_global_get(&mut self, offset: usize, global_index: u32) -> Self::Output { forward!(self.visit_global_get(offset, global_index)) } + fn visit_global_set(&mut self, offset: usize, global_index: u32) -> Self::Output { forward!(self.visit_global_set(offset, global_index)) } + fn visit_i32_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_load(offset, memarg)) } + fn visit_i64_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_load(offset, memarg)) } + fn visit_f32_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_f32_load(offset, memarg)) } + fn visit_f64_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_f64_load(offset, memarg)) } + fn visit_i32_load8_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_load8_s(offset, memarg)) } + fn visit_i32_load8_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_load8_u(offset, memarg)) } + fn visit_i32_load16_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_load16_s(offset, memarg)) } + fn visit_i32_load16_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_load16_u(offset, memarg)) } + fn visit_i64_load8_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_load8_s(offset, memarg)) } + fn visit_i64_load8_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_load8_u(offset, memarg)) } + fn visit_i64_load16_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_load16_s(offset, memarg)) } + fn visit_i64_load16_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_load16_u(offset, memarg)) } + fn visit_i64_load32_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_load32_s(offset, memarg)) } + fn visit_i64_load32_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_load32_u(offset, memarg)) } + fn visit_i32_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_store(offset, memarg)) } + fn visit_i64_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_store(offset, memarg)) } + fn visit_f32_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_f32_store(offset, memarg)) } + fn visit_f64_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_f64_store(offset, memarg)) } + fn visit_i32_store8(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_store8(offset, memarg)) } + fn visit_i32_store16(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_store16(offset, memarg)) } + fn visit_i64_store8(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_store8(offset, memarg)) } + fn visit_i64_store16(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_store16(offset, memarg)) } + fn visit_i64_store32(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_store32(offset, memarg)) } + fn visit_memory_size(&mut self, offset: usize, mem: u32, mem_byte: u8) -> Self::Output { forward!(self.visit_memory_size(offset, mem, mem_byte)) } + fn visit_memory_grow(&mut self, offset: usize, mem: u32, mem_byte: u8) -> Self::Output { forward!(self.visit_memory_grow(offset, mem, mem_byte)) } + fn visit_i32_const(&mut self, offset: usize, value: i32) -> Self::Output { forward!(self.visit_i32_const(offset, value)) } + fn visit_i64_const(&mut self, offset: usize, value: i64) -> Self::Output { forward!(self.visit_i64_const(offset, value)) } + fn visit_f32_const(&mut self, offset: usize, value: Ieee32) -> Self::Output { forward!(self.visit_f32_const(offset, value)) } + fn visit_f64_const(&mut self, offset: usize, value: Ieee64) -> Self::Output { forward!(self.visit_f64_const(offset, value)) } + fn visit_i32_eqz(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_eqz(offset)) } + fn visit_i32_eq(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_eq(offset)) } + fn visit_i32_ne(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_ne(offset)) } + fn visit_i32_lt_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_lt_s(offset)) } + fn visit_i32_lt_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_lt_u(offset)) } + fn visit_i32_gt_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_gt_s(offset)) } + fn visit_i32_gt_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_gt_u(offset)) } + fn visit_i32_le_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_le_s(offset)) } + fn visit_i32_le_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_le_u(offset)) } + fn visit_i32_ge_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_ge_s(offset)) } + fn visit_i32_ge_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_ge_u(offset)) } + fn visit_i64_eqz(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_eqz(offset)) } + fn visit_i64_eq(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_eq(offset)) } + fn visit_i64_ne(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_ne(offset)) } + fn visit_i64_lt_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_lt_s(offset)) } + fn visit_i64_lt_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_lt_u(offset)) } + fn visit_i64_gt_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_gt_s(offset)) } + fn visit_i64_gt_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_gt_u(offset)) } + fn visit_i64_le_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_le_s(offset)) } + fn visit_i64_le_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_le_u(offset)) } + fn visit_i64_ge_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_ge_s(offset)) } + fn visit_i64_ge_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_ge_u(offset)) } + fn visit_f32_eq(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_eq(offset)) } + fn visit_f32_ne(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_ne(offset)) } + fn visit_f32_lt(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_lt(offset)) } + fn visit_f32_gt(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_gt(offset)) } + fn visit_f32_le(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_le(offset)) } + fn visit_f32_ge(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_ge(offset)) } + fn visit_f64_eq(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_eq(offset)) } + fn visit_f64_ne(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_ne(offset)) } + fn visit_f64_lt(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_lt(offset)) } + fn visit_f64_gt(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_gt(offset)) } + fn visit_f64_le(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_le(offset)) } + fn visit_f64_ge(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_ge(offset)) } + fn visit_i32_clz(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_clz(offset)) } + fn visit_i32_ctz(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_ctz(offset)) } + fn visit_i32_popcnt(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_popcnt(offset)) } + fn visit_i32_add(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_add(offset)) } + fn visit_i32_sub(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_sub(offset)) } + fn visit_i32_mul(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_mul(offset)) } + fn visit_i32_div_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_div_s(offset)) } + fn visit_i32_div_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_div_u(offset)) } + fn visit_i32_rem_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_rem_s(offset)) } + fn visit_i32_rem_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_rem_u(offset)) } + fn visit_i32_and(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_and(offset)) } + fn visit_i32_or(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_or(offset)) } + fn visit_i32_xor(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_xor(offset)) } + fn visit_i32_shl(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_shl(offset)) } + fn visit_i32_shr_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_shr_s(offset)) } + fn visit_i32_shr_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_shr_u(offset)) } + fn visit_i32_rotl(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_rotl(offset)) } + fn visit_i32_rotr(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_rotr(offset)) } + fn visit_i64_clz(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_clz(offset)) } + fn visit_i64_ctz(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_ctz(offset)) } + fn visit_i64_popcnt(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_popcnt(offset)) } + fn visit_i64_add(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_add(offset)) } + fn visit_i64_sub(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_sub(offset)) } + fn visit_i64_mul(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_mul(offset)) } + fn visit_i64_div_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_div_s(offset)) } + fn visit_i64_div_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_div_u(offset)) } + fn visit_i64_rem_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_rem_s(offset)) } + fn visit_i64_rem_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_rem_u(offset)) } + fn visit_i64_and(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_and(offset)) } + fn visit_i64_or(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_or(offset)) } + fn visit_i64_xor(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_xor(offset)) } + fn visit_i64_shl(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_shl(offset)) } + fn visit_i64_shr_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_shr_s(offset)) } + fn visit_i64_shr_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_shr_u(offset)) } + fn visit_i64_rotl(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_rotl(offset)) } + fn visit_i64_rotr(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_rotr(offset)) } + fn visit_f32_abs(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_abs(offset)) } + fn visit_f32_neg(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_neg(offset)) } + fn visit_f32_ceil(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_ceil(offset)) } + fn visit_f32_floor(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_floor(offset)) } + fn visit_f32_trunc(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_trunc(offset)) } + fn visit_f32_nearest(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_nearest(offset)) } + fn visit_f32_sqrt(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_sqrt(offset)) } + fn visit_f32_add(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_add(offset)) } + fn visit_f32_sub(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_sub(offset)) } + fn visit_f32_mul(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_mul(offset)) } + fn visit_f32_div(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_div(offset)) } + fn visit_f32_min(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_min(offset)) } + fn visit_f32_max(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_max(offset)) } + fn visit_f32_copysign(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_copysign(offset)) } + fn visit_f64_abs(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_abs(offset)) } + fn visit_f64_neg(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_neg(offset)) } + fn visit_f64_ceil(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_ceil(offset)) } + fn visit_f64_floor(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_floor(offset)) } + fn visit_f64_trunc(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_trunc(offset)) } + fn visit_f64_nearest(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_nearest(offset)) } + fn visit_f64_sqrt(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_sqrt(offset)) } + fn visit_f64_add(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_add(offset)) } + fn visit_f64_sub(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_sub(offset)) } + fn visit_f64_mul(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_mul(offset)) } + fn visit_f64_div(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_div(offset)) } + fn visit_f64_min(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_min(offset)) } + fn visit_f64_max(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_max(offset)) } + fn visit_f64_copysign(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_copysign(offset)) } + fn visit_i32_wrap_i64(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_wrap_i64(offset)) } + fn visit_i32_trunc_f32s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_trunc_f32s(offset)) } + fn visit_i32_trunc_f32u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_trunc_f32u(offset)) } + fn visit_i32_trunc_f64s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_trunc_f64s(offset)) } + fn visit_i32_trunc_f64u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_trunc_f64u(offset)) } + fn visit_i64_extend_i32s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_extend_i32s(offset)) } + fn visit_i64_extend_i32u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_extend_i32u(offset)) } + fn visit_i64_trunc_f32s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_trunc_f32s(offset)) } + fn visit_i64_trunc_f32u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_trunc_f32u(offset)) } + fn visit_i64_trunc_f64s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_trunc_f64s(offset)) } + fn visit_i64_trunc_f64u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_trunc_f64u(offset)) } + fn visit_f32_convert_i32s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_convert_i32s(offset)) } + fn visit_f32_convert_i32u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_convert_i32u(offset)) } + fn visit_f32_convert_i64s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_convert_i64s(offset)) } + fn visit_f32_convert_i64u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_convert_i64u(offset)) } + fn visit_f32_demote_f64(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_demote_f64(offset)) } + fn visit_f64_convert_i32s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_convert_i32s(offset)) } + fn visit_f64_convert_i32u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_convert_i32u(offset)) } + fn visit_f64_convert_i64s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_convert_i64s(offset)) } + fn visit_f64_convert_i64u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_convert_i64u(offset)) } + fn visit_f64_promote_f32(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_promote_f32(offset)) } + fn visit_i32_reinterpret_f32(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_reinterpret_f32(offset)) } + fn visit_i64_reinterpret_f64(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_reinterpret_f64(offset)) } + fn visit_f32_reinterpret_i32(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32_reinterpret_i32(offset)) } + fn visit_f64_reinterpret_i64(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64_reinterpret_i64(offset)) } + fn visit_i32_trunc_sat_f32s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_trunc_sat_f32s(offset)) } + fn visit_i32_trunc_sat_f32u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_trunc_sat_f32u(offset)) } + fn visit_i32_trunc_sat_f64s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_trunc_sat_f64s(offset)) } + fn visit_i32_trunc_sat_f64u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_trunc_sat_f64u(offset)) } + fn visit_i64_trunc_sat_f32s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_trunc_sat_f32s(offset)) } + fn visit_i64_trunc_sat_f32u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_trunc_sat_f32u(offset)) } + fn visit_i64_trunc_sat_f64s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_trunc_sat_f64s(offset)) } + fn visit_i64_trunc_sat_f64u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_trunc_sat_f64u(offset)) } + fn visit_i32_extend8_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_extend8_s(offset)) } + fn visit_i32_extend16_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32_extend16_s(offset)) } + fn visit_i64_extend8_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_extend8_s(offset)) } + fn visit_i64_extend16_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_extend16_s(offset)) } + fn visit_i64_extend32_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64_extend32_s(offset)) } + fn visit_i32_atomic_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_load(offset, memarg)) } + fn visit_i32_atomic_load16_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_load16_u(offset, memarg)) } + fn visit_i32_atomic_load8_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_load8_u(offset, memarg)) } + fn visit_i64_atomic_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_load(offset, memarg)) } + fn visit_i64_atomic_load32_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_load32_u(offset, memarg)) } + fn visit_i64_atomic_load16_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_load16_u(offset, memarg)) } + fn visit_i64_atomic_load8_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_load8_u(offset, memarg)) } + fn visit_i32_atomic_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_store(offset, memarg)) } + fn visit_i32_atomic_store16(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_store16(offset, memarg)) } + fn visit_i32_atomic_store8(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_store8(offset, memarg)) } + fn visit_i64_atomic_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_store(offset, memarg)) } + fn visit_i64_atomic_store32(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_store32(offset, memarg)) } + fn visit_i64_atomic_store16(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_store16(offset, memarg)) } + fn visit_i64_atomic_store8(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_store8(offset, memarg)) } + fn visit_i32_atomic_rmw_add(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw_add(offset, memarg)) } + fn visit_i32_atomic_rmw_sub(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw_sub(offset, memarg)) } + fn visit_i32_atomic_rmw_and(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw_and(offset, memarg)) } + fn visit_i32_atomic_rmw_or(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw_or(offset, memarg)) } + fn visit_i32_atomic_rmw_xor(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw_xor(offset, memarg)) } + fn visit_i32_atomic_rmw16_add_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw16_add_u(offset, memarg)) } + fn visit_i32_atomic_rmw16_sub_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw16_sub_u(offset, memarg)) } + fn visit_i32_atomic_rmw16_and_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw16_and_u(offset, memarg)) } + fn visit_i32_atomic_rmw16_or_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw16_or_u(offset, memarg)) } + fn visit_i32_atomic_rmw16_xor_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw16_xor_u(offset, memarg)) } + fn visit_i32_atomic_rmw8_add_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw8_add_u(offset, memarg)) } + fn visit_i32_atomic_rmw8_sub_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw8_sub_u(offset, memarg)) } + fn visit_i32_atomic_rmw8_and_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw8_and_u(offset, memarg)) } + fn visit_i32_atomic_rmw8_or_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw8_or_u(offset, memarg)) } + fn visit_i32_atomic_rmw8_xor_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw8_xor_u(offset, memarg)) } + fn visit_i64_atomic_rmw_add(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw_add(offset, memarg)) } + fn visit_i64_atomic_rmw_sub(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw_sub(offset, memarg)) } + fn visit_i64_atomic_rmw_and(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw_and(offset, memarg)) } + fn visit_i64_atomic_rmw_or(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw_or(offset, memarg)) } + fn visit_i64_atomic_rmw_xor(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw_xor(offset, memarg)) } + fn visit_i64_atomic_rmw32_add_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw32_add_u(offset, memarg)) } + fn visit_i64_atomic_rmw32_sub_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw32_sub_u(offset, memarg)) } + fn visit_i64_atomic_rmw32_and_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw32_and_u(offset, memarg)) } + fn visit_i64_atomic_rmw32_or_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw32_or_u(offset, memarg)) } + fn visit_i64_atomic_rmw32_xor_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw32_xor_u(offset, memarg)) } + fn visit_i64_atomic_rmw16_add_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw16_add_u(offset, memarg)) } + fn visit_i64_atomic_rmw16_sub_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw16_sub_u(offset, memarg)) } + fn visit_i64_atomic_rmw16_and_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw16_and_u(offset, memarg)) } + fn visit_i64_atomic_rmw16_or_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw16_or_u(offset, memarg)) } + fn visit_i64_atomic_rmw16_xor_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw16_xor_u(offset, memarg)) } + fn visit_i64_atomic_rmw8_add_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw8_add_u(offset, memarg)) } + fn visit_i64_atomic_rmw8_sub_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw8_sub_u(offset, memarg)) } + fn visit_i64_atomic_rmw8_and_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw8_and_u(offset, memarg)) } + fn visit_i64_atomic_rmw8_or_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw8_or_u(offset, memarg)) } + fn visit_i64_atomic_rmw8_xor_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw8_xor_u(offset, memarg)) } + fn visit_i32_atomic_rmw_xchg(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw_xchg(offset, memarg)) } + fn visit_i32_atomic_rmw16_xchg_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw16_xchg_u(offset, memarg)) } + fn visit_i32_atomic_rmw8_xchg_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw8_xchg_u(offset, memarg)) } + fn visit_i32_atomic_rmw_cmpxchg(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw_cmpxchg(offset, memarg)) } + fn visit_i32_atomic_rmw16_cmpxchg_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw16_cmpxchg_u(offset, memarg)) } + fn visit_i32_atomic_rmw8_cmpxchg_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i32_atomic_rmw8_cmpxchg_u(offset, memarg)) } + fn visit_i64_atomic_rmw_xchg(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw_xchg(offset, memarg)) } + fn visit_i64_atomic_rmw32_xchg_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw32_xchg_u(offset, memarg)) } + fn visit_i64_atomic_rmw16_xchg_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw16_xchg_u(offset, memarg)) } + fn visit_i64_atomic_rmw8_xchg_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw8_xchg_u(offset, memarg)) } + fn visit_i64_atomic_rmw_cmpxchg(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw_cmpxchg(offset, memarg)) } + fn visit_i64_atomic_rmw32_cmpxchg_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw32_cmpxchg_u(offset, memarg)) } + fn visit_i64_atomic_rmw16_cmpxchg_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw16_cmpxchg_u(offset, memarg)) } + fn visit_i64_atomic_rmw8_cmpxchg_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_i64_atomic_rmw8_cmpxchg_u(offset, memarg)) } + fn visit_memory_atomic_notify(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_memory_atomic_notify(offset, memarg)) } + fn visit_memory_atomic_wait32(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_memory_atomic_wait32(offset, memarg)) } + fn visit_memory_atomic_wait64(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_memory_atomic_wait64(offset, memarg)) } + fn visit_atomic_fence(&mut self, offset: usize, flags: u8) -> Self::Output { forward!(self.visit_atomic_fence(offset, flags)) } + fn visit_ref_null(&mut self, offset: usize, ty: ValType) -> Self::Output { forward!(self.visit_ref_null(offset, ty)) } + fn visit_ref_is_null(&mut self, offset: usize) -> Self::Output { forward!(self.visit_ref_is_null(offset)) } + fn visit_ref_func(&mut self, offset: usize, function_index: u32) -> Self::Output { forward!(self.visit_ref_func(offset, function_index)) } + fn visit_v128_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_v128_load(offset, memarg)) } + fn visit_v128_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_v128_store(offset, memarg)) } + fn visit_v128_const(&mut self, offset: usize, value: V128) -> Self::Output { forward!(self.visit_v128_const(offset, value)) } + fn visit_i8x16_splat(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_splat(offset)) } + fn visit_i16x8_splat(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_splat(offset)) } + fn visit_i32x4_splat(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_splat(offset)) } + fn visit_i64x2_splat(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_splat(offset)) } + fn visit_f32x4_splat(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_splat(offset)) } + fn visit_f64x2_splat(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_splat(offset)) } + fn visit_i8x16_extract_lane_s(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_i8x16_extract_lane_s(offset, lane)) } + fn visit_i8x16_extract_lane_u(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_i8x16_extract_lane_u(offset, lane)) } + fn visit_i16x8_extract_lane_s(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_i16x8_extract_lane_s(offset, lane)) } + fn visit_i16x8_extract_lane_u(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_i16x8_extract_lane_u(offset, lane)) } + fn visit_i32x4_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_i32x4_extract_lane(offset, lane)) } + fn visit_i8x16_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_i8x16_replace_lane(offset, lane)) } + fn visit_i16x8_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_i16x8_replace_lane(offset, lane)) } + fn visit_i32x4_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_i32x4_replace_lane(offset, lane)) } + fn visit_i64x2_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_i64x2_extract_lane(offset, lane)) } + fn visit_i64x2_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_i64x2_replace_lane(offset, lane)) } + fn visit_f32x4_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_f32x4_extract_lane(offset, lane)) } + fn visit_f32x4_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_f32x4_replace_lane(offset, lane)) } + fn visit_f64x2_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_f64x2_extract_lane(offset, lane)) } + fn visit_f64x2_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_f64x2_replace_lane(offset, lane)) } + fn visit_f32x4_eq(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_eq(offset)) } + fn visit_f32x4_ne(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_ne(offset)) } + fn visit_f32x4_lt(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_lt(offset)) } + fn visit_f32x4_gt(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_gt(offset)) } + fn visit_f32x4_le(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_le(offset)) } + fn visit_f32x4_ge(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_ge(offset)) } + fn visit_f64x2_eq(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_eq(offset)) } + fn visit_f64x2_ne(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_ne(offset)) } + fn visit_f64x2_lt(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_lt(offset)) } + fn visit_f64x2_gt(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_gt(offset)) } + fn visit_f64x2_le(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_le(offset)) } + fn visit_f64x2_ge(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_ge(offset)) } + fn visit_f32x4_add(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_add(offset)) } + fn visit_f32x4_sub(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_sub(offset)) } + fn visit_f32x4_mul(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_mul(offset)) } + fn visit_f32x4_div(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_div(offset)) } + fn visit_f32x4_min(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_min(offset)) } + fn visit_f32x4_max(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_max(offset)) } + fn visit_f32x4_p_min(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_p_min(offset)) } + fn visit_f32x4_p_max(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_p_max(offset)) } + fn visit_f64x2_add(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_add(offset)) } + fn visit_f64x2_sub(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_sub(offset)) } + fn visit_f64x2_mul(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_mul(offset)) } + fn visit_f64x2_div(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_div(offset)) } + fn visit_f64x2_min(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_min(offset)) } + fn visit_f64x2_max(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_max(offset)) } + fn visit_f64x2_p_min(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_p_min(offset)) } + fn visit_f64x2_p_max(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_p_max(offset)) } + fn visit_f32x4_relaxed_min(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_relaxed_min(offset)) } + fn visit_f32x4_relaxed_max(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_relaxed_max(offset)) } + fn visit_f64x2_relaxed_min(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_relaxed_min(offset)) } + fn visit_f64x2_relaxed_max(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_relaxed_max(offset)) } + fn visit_i8x16_eq(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_eq(offset)) } + fn visit_i8x16_ne(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_ne(offset)) } + fn visit_i8x16_lt_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_lt_s(offset)) } + fn visit_i8x16_lt_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_lt_u(offset)) } + fn visit_i8x16_gt_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_gt_s(offset)) } + fn visit_i8x16_gt_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_gt_u(offset)) } + fn visit_i8x16_le_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_le_s(offset)) } + fn visit_i8x16_le_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_le_u(offset)) } + fn visit_i8x16_ge_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_ge_s(offset)) } + fn visit_i8x16_ge_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_ge_u(offset)) } + fn visit_i16x8_eq(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_eq(offset)) } + fn visit_i16x8_ne(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_ne(offset)) } + fn visit_i16x8_lt_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_lt_s(offset)) } + fn visit_i16x8_lt_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_lt_u(offset)) } + fn visit_i16x8_gt_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_gt_s(offset)) } + fn visit_i16x8_gt_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_gt_u(offset)) } + fn visit_i16x8_le_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_le_s(offset)) } + fn visit_i16x8_le_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_le_u(offset)) } + fn visit_i16x8_ge_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_ge_s(offset)) } + fn visit_i16x8_ge_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_ge_u(offset)) } + fn visit_i32x4_eq(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_eq(offset)) } + fn visit_i32x4_ne(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_ne(offset)) } + fn visit_i32x4_lt_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_lt_s(offset)) } + fn visit_i32x4_lt_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_lt_u(offset)) } + fn visit_i32x4_gt_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_gt_s(offset)) } + fn visit_i32x4_gt_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_gt_u(offset)) } + fn visit_i32x4_le_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_le_s(offset)) } + fn visit_i32x4_le_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_le_u(offset)) } + fn visit_i32x4_ge_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_ge_s(offset)) } + fn visit_i32x4_ge_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_ge_u(offset)) } + fn visit_i64x2_eq(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_eq(offset)) } + fn visit_i64x2_ne(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_ne(offset)) } + fn visit_i64x2_lt_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_lt_s(offset)) } + fn visit_i64x2_gt_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_gt_s(offset)) } + fn visit_i64x2_le_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_le_s(offset)) } + fn visit_i64x2_ge_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_ge_s(offset)) } + fn visit_v128_and(&mut self, offset: usize) -> Self::Output { forward!(self.visit_v128_and(offset)) } + fn visit_v128_and_not(&mut self, offset: usize) -> Self::Output { forward!(self.visit_v128_and_not(offset)) } + fn visit_v128_or(&mut self, offset: usize) -> Self::Output { forward!(self.visit_v128_or(offset)) } + fn visit_v128_xor(&mut self, offset: usize) -> Self::Output { forward!(self.visit_v128_xor(offset)) } + fn visit_i8x16_add(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_add(offset)) } + fn visit_i8x16_add_sat_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_add_sat_s(offset)) } + fn visit_i8x16_add_sat_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_add_sat_u(offset)) } + fn visit_i8x16_sub(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_sub(offset)) } + fn visit_i8x16_sub_sat_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_sub_sat_s(offset)) } + fn visit_i8x16_sub_sat_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_sub_sat_u(offset)) } + fn visit_i8x16_min_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_min_s(offset)) } + fn visit_i8x16_min_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_min_u(offset)) } + fn visit_i8x16_max_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_max_s(offset)) } + fn visit_i8x16_max_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_max_u(offset)) } + fn visit_i16x8_add(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_add(offset)) } + fn visit_i16x8_add_sat_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_add_sat_s(offset)) } + fn visit_i16x8_add_sat_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_add_sat_u(offset)) } + fn visit_i16x8_sub(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_sub(offset)) } + fn visit_i16x8_sub_sat_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_sub_sat_s(offset)) } + fn visit_i16x8_sub_sat_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_sub_sat_u(offset)) } + fn visit_i16x8_mul(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_mul(offset)) } + fn visit_i16x8_min_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_min_s(offset)) } + fn visit_i16x8_min_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_min_u(offset)) } + fn visit_i16x8_max_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_max_s(offset)) } + fn visit_i16x8_max_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_max_u(offset)) } + fn visit_i32x4_add(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_add(offset)) } + fn visit_i32x4_sub(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_sub(offset)) } + fn visit_i32x4_mul(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_mul(offset)) } + fn visit_i32x4_min_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_min_s(offset)) } + fn visit_i32x4_min_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_min_u(offset)) } + fn visit_i32x4_max_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_max_s(offset)) } + fn visit_i32x4_max_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_max_u(offset)) } + fn visit_i32x4_dot_i16x8_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_dot_i16x8_s(offset)) } + fn visit_i64x2_add(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_add(offset)) } + fn visit_i64x2_sub(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_sub(offset)) } + fn visit_i64x2_mul(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_mul(offset)) } + fn visit_i8x16_rounding_average_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_rounding_average_u(offset)) } + fn visit_i16x8_rounding_average_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_rounding_average_u(offset)) } + fn visit_i8x16_narrow_i16x8_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_narrow_i16x8_s(offset)) } + fn visit_i8x16_narrow_i16x8_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_narrow_i16x8_u(offset)) } + fn visit_i16x8_narrow_i32x4_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_narrow_i32x4_s(offset)) } + fn visit_i16x8_narrow_i32x4_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_narrow_i32x4_u(offset)) } + fn visit_i16x8_ext_mul_low_i8x16_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_ext_mul_low_i8x16_s(offset)) } + fn visit_i16x8_ext_mul_high_i8x16_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_ext_mul_high_i8x16_s(offset)) } + fn visit_i16x8_ext_mul_low_i8x16_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_ext_mul_low_i8x16_u(offset)) } + fn visit_i16x8_ext_mul_high_i8x16_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_ext_mul_high_i8x16_u(offset)) } + fn visit_i32x4_ext_mul_low_i16x8_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_ext_mul_low_i16x8_s(offset)) } + fn visit_i32x4_ext_mul_high_i16x8_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_ext_mul_high_i16x8_s(offset)) } + fn visit_i32x4_ext_mul_low_i16x8_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_ext_mul_low_i16x8_u(offset)) } + fn visit_i32x4_ext_mul_high_i16x8_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_ext_mul_high_i16x8_u(offset)) } + fn visit_i64x2_ext_mul_low_i32x4_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_ext_mul_low_i32x4_s(offset)) } + fn visit_i64x2_ext_mul_high_i32x4_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_ext_mul_high_i32x4_s(offset)) } + fn visit_i64x2_ext_mul_low_i32x4_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_ext_mul_low_i32x4_u(offset)) } + fn visit_i64x2_ext_mul_high_i32x4_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_ext_mul_high_i32x4_u(offset)) } + fn visit_i16x8_q15_mulr_sat_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_q15_mulr_sat_s(offset)) } + fn visit_f32x4_ceil(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_ceil(offset)) } + fn visit_f32x4_floor(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_floor(offset)) } + fn visit_f32x4_trunc(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_trunc(offset)) } + fn visit_f32x4_nearest(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_nearest(offset)) } + fn visit_f64x2_ceil(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_ceil(offset)) } + fn visit_f64x2_floor(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_floor(offset)) } + fn visit_f64x2_trunc(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_trunc(offset)) } + fn visit_f64x2_nearest(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_nearest(offset)) } + fn visit_f32x4_abs(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_abs(offset)) } + fn visit_f32x4_neg(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_neg(offset)) } + fn visit_f32x4_sqrt(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_sqrt(offset)) } + fn visit_f64x2_abs(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_abs(offset)) } + fn visit_f64x2_neg(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_neg(offset)) } + fn visit_f64x2_sqrt(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_sqrt(offset)) } + fn visit_f32x4_demote_f64x2_zero(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_demote_f64x2_zero(offset)) } + fn visit_f64x2_promote_low_f32x4(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_promote_low_f32x4(offset)) } + fn visit_f64x2_convert_low_i32x4_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_convert_low_i32x4_s(offset)) } + fn visit_f64x2_convert_low_i32x4_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_convert_low_i32x4_u(offset)) } + fn visit_i32x4_trunc_sat_f32x4_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_trunc_sat_f32x4_s(offset)) } + fn visit_i32x4_trunc_sat_f32x4_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_trunc_sat_f32x4_u(offset)) } + fn visit_i32x4_trunc_sat_f64x2_s_zero(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_trunc_sat_f64x2_s_zero(offset)) } + fn visit_i32x4_trunc_sat_f64x2_u_zero(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_trunc_sat_f64x2_u_zero(offset)) } + fn visit_f32x4_convert_i32x4_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_convert_i32x4_s(offset)) } + fn visit_f32x4_convert_i32x4_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_convert_i32x4_u(offset)) } + fn visit_v128_not(&mut self, offset: usize) -> Self::Output { forward!(self.visit_v128_not(offset)) } + fn visit_i8x16_abs(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_abs(offset)) } + fn visit_i8x16_neg(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_neg(offset)) } + fn visit_i8x16_popcnt(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_popcnt(offset)) } + fn visit_i16x8_abs(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_abs(offset)) } + fn visit_i16x8_neg(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_neg(offset)) } + fn visit_i32x4_abs(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_abs(offset)) } + fn visit_i32x4_neg(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_neg(offset)) } + fn visit_i64x2_abs(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_abs(offset)) } + fn visit_i64x2_neg(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_neg(offset)) } + fn visit_i16x8_extend_low_i8x16_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_extend_low_i8x16_s(offset)) } + fn visit_i16x8_extend_high_i8x16_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_extend_high_i8x16_s(offset)) } + fn visit_i16x8_extend_low_i8x16_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_extend_low_i8x16_u(offset)) } + fn visit_i16x8_extend_high_i8x16_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_extend_high_i8x16_u(offset)) } + fn visit_i32x4_extend_low_i16x8_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_extend_low_i16x8_s(offset)) } + fn visit_i32x4_extend_high_i16x8_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_extend_high_i16x8_s(offset)) } + fn visit_i32x4_extend_low_i16x8_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_extend_low_i16x8_u(offset)) } + fn visit_i32x4_extend_high_i16x8_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_extend_high_i16x8_u(offset)) } + fn visit_i64x2_extend_low_i32x4_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_extend_low_i32x4_s(offset)) } + fn visit_i64x2_extend_high_i32x4_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_extend_high_i32x4_s(offset)) } + fn visit_i64x2_extend_low_i32x4_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_extend_low_i32x4_u(offset)) } + fn visit_i64x2_extend_high_i32x4_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_extend_high_i32x4_u(offset)) } + fn visit_i16x8_ext_add_pairwise_i8x16_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_ext_add_pairwise_i8x16_s(offset)) } + fn visit_i16x8_ext_add_pairwise_i8x16_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_ext_add_pairwise_i8x16_u(offset)) } + fn visit_i32x4_ext_add_pairwise_i16x8_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_ext_add_pairwise_i16x8_s(offset)) } + fn visit_i32x4_ext_add_pairwise_i16x8_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_ext_add_pairwise_i16x8_u(offset)) } + fn visit_i32x4_relaxed_trunc_sat_f32x4_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_relaxed_trunc_sat_f32x4_s(offset)) } + fn visit_i32x4_relaxed_trunc_sat_f32x4_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_relaxed_trunc_sat_f32x4_u(offset)) } + fn visit_i32x4_relaxed_trunc_sat_f64x2_s_zero(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_relaxed_trunc_sat_f64x2_s_zero(offset)) } + fn visit_i32x4_relaxed_trunc_sat_f64x2_u_zero(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_relaxed_trunc_sat_f64x2_u_zero(offset)) } + fn visit_v128_bitselect(&mut self, offset: usize) -> Self::Output { forward!(self.visit_v128_bitselect(offset)) } + fn visit_f32x4_fma(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_fma(offset)) } + fn visit_f32x4_fms(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f32x4_fms(offset)) } + fn visit_f64x2_fma(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_fma(offset)) } + fn visit_f64x2_fms(&mut self, offset: usize) -> Self::Output { forward!(self.visit_f64x2_fms(offset)) } + fn visit_i8x16_lane_select(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_lane_select(offset)) } + fn visit_i16x8_lane_select(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_lane_select(offset)) } + fn visit_i32x4_lane_select(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_lane_select(offset)) } + fn visit_i64x2_lane_select(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_lane_select(offset)) } + fn visit_v128_any_true(&mut self, offset: usize) -> Self::Output { forward!(self.visit_v128_any_true(offset)) } + fn visit_i8x16_all_true(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_all_true(offset)) } + fn visit_i8x16_bitmask(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_bitmask(offset)) } + fn visit_i16x8_all_true(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_all_true(offset)) } + fn visit_i16x8_bitmask(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_bitmask(offset)) } + fn visit_i32x4_all_true(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_all_true(offset)) } + fn visit_i32x4_bitmask(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_bitmask(offset)) } + fn visit_i64x2_all_true(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_all_true(offset)) } + fn visit_i64x2_bitmask(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_bitmask(offset)) } + fn visit_i8x16_shl(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_shl(offset)) } + fn visit_i8x16_shr_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_shr_s(offset)) } + fn visit_i8x16_shr_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_shr_u(offset)) } + fn visit_i16x8_shl(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_shl(offset)) } + fn visit_i16x8_shr_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_shr_s(offset)) } + fn visit_i16x8_shr_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i16x8_shr_u(offset)) } + fn visit_i32x4_shl(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_shl(offset)) } + fn visit_i32x4_shr_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_shr_s(offset)) } + fn visit_i32x4_shr_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i32x4_shr_u(offset)) } + fn visit_i64x2_shl(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_shl(offset)) } + fn visit_i64x2_shr_s(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_shr_s(offset)) } + fn visit_i64x2_shr_u(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i64x2_shr_u(offset)) } + fn visit_i8x16_swizzle(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_swizzle(offset)) } + fn visit_i8x16_relaxed_swizzle(&mut self, offset: usize) -> Self::Output { forward!(self.visit_i8x16_relaxed_swizzle(offset)) } + fn visit_i8x16_shuffle(&mut self, offset: usize, lanes: [SIMDLaneIndex; 16]) -> Self::Output { forward!(self.visit_i8x16_shuffle(offset, lanes)) } + fn visit_v128_load8_splat(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_v128_load8_splat(offset, memarg)) } + fn visit_v128_load16_splat(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_v128_load16_splat(offset, memarg)) } + fn visit_v128_load32_splat(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_v128_load32_splat(offset, memarg)) } + fn visit_v128_load32_zero(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_v128_load32_zero(offset, memarg)) } + fn visit_v128_load64_splat(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_v128_load64_splat(offset, memarg)) } + fn visit_v128_load64_zero(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_v128_load64_zero(offset, memarg)) } + fn visit_v128_load8x8_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_v128_load8x8_s(offset, memarg)) } + fn visit_v128_load8x8_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_v128_load8x8_u(offset, memarg)) } + fn visit_v128_load16x4_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_v128_load16x4_s(offset, memarg)) } + fn visit_v128_load16x4_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_v128_load16x4_u(offset, memarg)) } + fn visit_v128_load32x2_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_v128_load32x2_s(offset, memarg)) } + fn visit_v128_load32x2_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { forward!(self.visit_v128_load32x2_u(offset, memarg)) } + fn visit_v128_load8_lane(&mut self, offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_v128_load8_lane(offset, memarg, lane)) } + fn visit_v128_load16_lane(&mut self, offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_v128_load16_lane(offset, memarg, lane)) } + fn visit_v128_load32_lane(&mut self, offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_v128_load32_lane(offset, memarg, lane)) } + fn visit_v128_load64_lane(&mut self, offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_v128_load64_lane(offset, memarg, lane)) } + fn visit_v128_store8_lane(&mut self, offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_v128_store8_lane(offset, memarg, lane)) } + fn visit_v128_store16_lane(&mut self, offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_v128_store16_lane(offset, memarg, lane)) } + fn visit_v128_store32_lane(&mut self, offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_v128_store32_lane(offset, memarg, lane)) } + fn visit_v128_store64_lane(&mut self, offset: usize, memarg: MemoryImmediate, lane: SIMDLaneIndex) -> Self::Output { forward!(self.visit_v128_store64_lane(offset, memarg, lane)) } + fn visit_memory_init(&mut self, offset: usize, mem: u32, segment: u32) -> Self::Output { forward!(self.visit_memory_init(offset, mem, segment)) } + fn visit_data_drop(&mut self, offset: usize, segment: u32) -> Self::Output { forward!(self.visit_data_drop(offset, segment)) } + fn visit_memory_copy(&mut self, offset: usize, src: u32, dst: u32) -> Self::Output { forward!(self.visit_memory_copy(offset, src, dst)) } + fn visit_memory_fill(&mut self, offset: usize, mem: u32) -> Self::Output { forward!(self.visit_memory_fill(offset, mem)) } + fn visit_table_init(&mut self, offset: usize, segment: u32, table: u32) -> Self::Output { forward!(self.visit_table_init(offset, segment, table)) } + fn visit_elem_drop(&mut self, offset: usize, segment: u32) -> Self::Output { forward!(self.visit_elem_drop(offset, segment)) } + fn visit_table_copy(&mut self, offset: usize, dst_table: u32, src_table: u32) -> Self::Output { forward!(self.visit_table_copy(offset, dst_table, src_table)) } + fn visit_table_get(&mut self, offset: usize, table: u32) -> Self::Output { forward!(self.visit_table_get(offset, table)) } + fn visit_table_set(&mut self, offset: usize, table: u32) -> Self::Output { forward!(self.visit_table_set(offset, table)) } + fn visit_table_grow(&mut self, offset: usize, table: u32) -> Self::Output { forward!(self.visit_table_grow(offset, table)) } + fn visit_table_size(&mut self, offset: usize, table: u32) -> Self::Output { forward!(self.visit_table_size(offset, table)) } + fn visit_table_fill(&mut self, offset: usize, table: u32) -> Self::Output { forward!(self.visit_table_fill(offset, table)) } + + fn visit_memory_read_pkru(&mut self, offset: usize) -> Self::Output { forward!(self.visit_memory_read_pkru(offset)) } + fn visit_memory_write_pkru(&mut self, offset: usize) -> Self::Output { forward!(self.visit_memory_read_pkru(offset)) } +} diff --git a/crates/wasmparser/src/validator/operators.rs b/crates/wasmparser/src/validator/operators.rs new file mode 100644 index 000000000..7578a3beb --- /dev/null +++ b/crates/wasmparser/src/validator/operators.rs @@ -0,0 +1,3396 @@ +/* Copyright 2019 Mozilla Foundation + * + * 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 basic validation algorithm here is copied from the "Validation +// Algorithm" section of the WebAssembly specification - +// https://webassembly.github.io/spec/core/appendix/algorithm.html. +// +// That algorithm is followed pretty closely here, namely `push_operand`, +// `pop_operand`, `push_ctrl`, and `pop_ctrl`. If anything here is a bit +// confusing it's recommended to read over that section to see how it maps to +// the various methods here. + +use crate::{ + limits::MAX_WASM_FUNCTION_LOCALS, BinaryReaderError, BlockType, BrTable, Ieee32, Ieee64, + MemoryImmediate, Result, SIMDLaneIndex, ValType, VisitOperator, WasmFeatures, WasmFuncType, + WasmModuleResources, V128, +}; +use std::ops::{Deref, DerefMut}; + +/// Create a `BinaryReaderError` with a format string. +macro_rules! format_op_err { + ( $offset:expr, $( $arg:expr ),* $(,)* ) => { + BinaryReaderError::new(format!( $( $arg ),* ), $offset) + } +} + +/// Early return an `Err(BinaryReaderError)` with a format string. +macro_rules! bail_op_err { + ( $offset:expr, $( $arg:expr ),* $(,)* ) => { + return Err(format_op_err!( $offset, $( $arg ),* )) + } +} + +pub(crate) struct OperatorValidator { + // The total number of locals that this function contains + num_locals: u32, + // This is a "compressed" list of locals for this function. The list of + // locals are represented as a list of tuples. The second element is the + // type of the local, and the first element is monotonically increasing as + // you visit elements of this list. The first element is the maximum index + // of the local, after the previous index, of the type specified. + // + // This allows us to do a binary search on the list for a local's index for + // `local.{get,set,tee}`. We do a binary search for the index desired, and + // it either lies in a "hole" where the maximum index is specified later, + // or it's at the end of the list meaning it's out of bounds. + locals: Vec<(u32, ValType)>, + + // This is a list of flags for wasm features which are used to gate various + // instructions. + pub(crate) features: WasmFeatures, + + // Temporary storage used during the validation of `br_table`. + br_table_tmp: Vec>, + + /// The `control` list is the list of blocks that we're currently in. + control: Vec, + /// The `operands` is the current type stack. + operands: Vec>, + + /// Offset of the `end` instruction which emptied the `control` stack, which + /// must be the end of the function. + end_which_emptied_control: Option, +} + +// This structure corresponds to `ctrl_frame` as specified at in the validation +// appendix of the wasm spec +#[derive(Debug)] +struct Frame { + // Indicator for what kind of instruction pushed this frame. + kind: FrameKind, + // The type signature of this frame, represented as a singular return type + // or a type index pointing into the module's types. + block_type: BlockType, + // The index, below which, this frame cannot modify the operand stack. + height: usize, + // Whether this frame is unreachable so far. + unreachable: bool, +} + +#[derive(PartialEq, Copy, Clone, Debug)] +enum FrameKind { + Block, + If, + Else, + Loop, + Try, + Catch, + CatchAll, +} + +struct OperatorValidatorTemp<'validator, 'resources, T> { + inner: &'validator mut OperatorValidator, + resources: &'resources T, +} + +impl OperatorValidator { + /// Creates a new operator validator which will be used to validate a + /// function whose type is the `ty` index specified. + /// + /// The `resources` are used to learn about the function type underlying + /// `ty`. + pub fn new_func( + ty: u32, + offset: usize, + features: &WasmFeatures, + resources: &T, + ) -> Result + where + T: WasmModuleResources, + { + let mut ret = OperatorValidator { + num_locals: 0, + locals: Vec::new(), + features: *features, + br_table_tmp: Vec::new(), + operands: Vec::new(), + control: vec![Frame { + kind: FrameKind::Block, + block_type: BlockType::FuncType(ty), + height: 0, + unreachable: false, + }], + end_which_emptied_control: None, + }; + let locals = OperatorValidatorTemp { + inner: &mut ret, + resources, + } + .func_type_at(ty, offset)? + .inputs() + .enumerate() + .map(|(i, ty)| (i as u32, ty)) + .collect::>(); + ret.num_locals = locals.len() as u32; + ret.locals = locals; + Ok(ret) + } + + /// Creates a new operator validator which will be used to validate an + /// `init_expr` constant expression which should result in the `ty` + /// specified. + pub fn new_const_expr(features: &WasmFeatures, ty: ValType) -> Self { + OperatorValidator { + num_locals: 0, + locals: Vec::new(), + features: *features, + br_table_tmp: Vec::new(), + operands: Vec::new(), + control: vec![Frame { + kind: FrameKind::Block, + block_type: BlockType::Type(ty), + height: 0, + unreachable: false, + }], + end_which_emptied_control: None, + } + } + + pub fn define_locals(&mut self, offset: usize, count: u32, ty: ValType) -> Result<()> { + self.features + .check_value_type(ty) + .map_err(|e| BinaryReaderError::new(e, offset))?; + if count == 0 { + return Ok(()); + } + match self.num_locals.checked_add(count) { + Some(n) => self.num_locals = n, + None => return Err(BinaryReaderError::new("locals overflow", offset)), + } + if self.num_locals > (MAX_WASM_FUNCTION_LOCALS as u32) { + return Err(BinaryReaderError::new( + "too many locals: locals exceed maximum", + offset, + )); + } + self.locals.push((self.num_locals - 1, ty)); + Ok(()) + } + + pub fn operand_stack_height(&self) -> usize { + self.operands.len() + } + + /// Create a temporary [`OperatorValidatorTemp`] for validation. + pub fn with_resources<'validator, 'resources, T>( + &'validator mut self, + resources: &'resources T, + ) -> impl VisitOperator> + 'validator + where + T: WasmModuleResources, + 'resources: 'validator, + { + OperatorValidatorTemp { + inner: self, + resources, + } + } + + pub fn finish(&mut self, offset: usize) -> Result<()> { + if self.control.last().is_some() { + bail_op_err!( + offset, + "control frames remain at end of function: END opcode expected" + ); + } + + // The `end` opcode is one byte which means that the `offset` here + // should point just beyond the `end` opcode which emptied the control + // stack. If not that means more instructions were present after the + // control stack was emptied. + if offset != self.end_which_emptied_control.unwrap() + 1 { + return Err(self.err_beyond_end(offset)); + } + Ok(()) + } + + fn err_beyond_end(&self, offset: usize) -> BinaryReaderError { + format_op_err!(offset, "operators remaining after end of function") + } +} + +impl Deref for OperatorValidatorTemp<'_, '_, R> { + type Target = OperatorValidator; + fn deref(&self) -> &OperatorValidator { + &self.inner + } +} + +impl DerefMut for OperatorValidatorTemp<'_, '_, R> { + fn deref_mut(&mut self) -> &mut OperatorValidator { + &mut self.inner + } +} + +impl<'resources, R: WasmModuleResources> OperatorValidatorTemp<'_, 'resources, R> { + /// Pushes a type onto the operand stack. + /// + /// This is used by instructions to represent a value that is pushed to the + /// operand stack. This can fail, but only if `Type` is feature gated. + /// Otherwise the push operation always succeeds. + fn push_operand(&mut self, ty: T) -> Result<()> + where + T: Into>, + { + let maybe_ty = ty.into(); + self.operands.push(maybe_ty); + Ok(()) + } + + /// Attempts to pop a type from the operand stack. + /// + /// This function is used to remove types from the operand stack. The + /// `expected` argument can be used to indicate that a type is required, or + /// simply that something is needed to be popped. + /// + /// If `expected` is `Some(T)` then this will be guaranteed to return + /// `Some(T)`, and it will only return success if the current block is + /// unreachable or if `T` was found at the top of the operand stack. + /// + /// If `expected` is `None` then it indicates that something must be on the + /// operand stack, but it doesn't matter what's on the operand stack. This + /// is useful for polymorphic instructions like `select`. + /// + /// If `Some(T)` is returned then `T` was popped from the operand stack and + /// matches `expected`. If `None` is returned then it means that `None` was + /// expected and a type was successfully popped, but its exact type is + /// indeterminate because the current block is unreachable. + fn pop_operand(&mut self, offset: usize, expected: Option) -> Result> { + let control = match self.control.last() { + Some(c) => c, + None => return Err(self.err_beyond_end(offset)), + }; + let actual = if self.operands.len() == control.height { + if control.unreachable { + None + } else { + let desc = match expected { + Some(ty) => ty_to_str(ty), + None => "a type", + }; + bail_op_err!( + offset, + "type mismatch: expected {} but nothing on stack", + desc + ) + } + } else { + self.operands.pop().unwrap() + }; + if let (Some(actual_ty), Some(expected_ty)) = (actual, expected) { + if actual_ty != expected_ty { + bail_op_err!( + offset, + "type mismatch: expected {}, found {}", + ty_to_str(expected_ty), + ty_to_str(actual_ty) + ) + } + } + Ok(actual) + } + + /// Fetches the type for the local at `idx`, returning an error if it's out + /// of bounds. + fn local(&self, offset: usize, idx: u32) -> Result { + match self + .inner + .locals + .binary_search_by_key(&idx, |(idx, _)| *idx) + { + // If this index would be inserted at the end of the list, then the + // index is out of bounds and we return an error. + Err(i) if i == self.locals.len() => { + bail_op_err!(offset, "unknown local {}: local index out of bounds", idx) + } + // If `Ok` is returned we found the index exactly, or if `Err` is + // returned the position is the one which is the least index + // greater that `idx`, which is still the type of `idx` according + // to our "compressed" representation. In both cases we access the + // list at index `i`. + Ok(i) | Err(i) => Ok(self.locals[i].1), + } + } + + /// Flags the current control frame as unreachable, additionally truncating + /// the currently active operand stack. + fn unreachable(&mut self, offset: usize) -> Result<()> { + let control = match self.control.last_mut() { + Some(frame) => frame, + None => return Err(self.err_beyond_end(offset)), + }; + control.unreachable = true; + let new_height = control.height; + self.operands.truncate(new_height); + Ok(()) + } + + /// Pushes a new frame onto the control stack. + /// + /// This operation is used when entering a new block such as an if, loop, + /// or block itself. The `kind` of block is specified which indicates how + /// breaks interact with this block's type. Additionally the type signature + /// of the block is specified by `ty`. + fn push_ctrl(&mut self, offset: usize, kind: FrameKind, ty: BlockType) -> Result<()> { + // Push a new frame which has a snapshot of the height of the current + // operand stack. + let height = self.operands.len(); + self.control.push(Frame { + kind, + block_type: ty, + height, + unreachable: false, + }); + // All of the parameters are now also available in this control frame, + // so we push them here in order. + for ty in self.params(offset, ty)? { + self.push_operand(ty)?; + } + Ok(()) + } + + /// Pops a frame from the control stack. + /// + /// This function is used when exiting a block and leaves a block scope. + /// Internally this will validate that blocks have the correct result type. + fn pop_ctrl(&mut self, offset: usize) -> Result { + // Read the expected type and expected height of the operand stack the + // end of the frame. + let frame = match self.control.last() { + Some(f) => f, + None => return Err(self.err_beyond_end(offset)), + }; + let ty = frame.block_type; + let height = frame.height; + + // Pop all the result types, in reverse order, from the operand stack. + // These types will, possibly, be transferred to the next frame. + for ty in self.results(offset, ty)?.rev() { + self.pop_operand(offset, Some(ty))?; + } + + // Make sure that the operand stack has returned to is original + // height... + if self.operands.len() != height { + bail_op_err!( + offset, + "type mismatch: values remaining on stack at end of block" + ); + } + + // And then we can remove it! + Ok(self.control.pop().unwrap()) + } + + /// Validates a relative jump to the `depth` specified. + /// + /// Returns the type signature of the block that we're jumping to as well + /// as the kind of block if the jump is valid. Otherwise returns an error. + fn jump(&self, offset: usize, depth: u32) -> Result<(BlockType, FrameKind)> { + if self.control.len() == 0 { + return Err(self.err_beyond_end(offset)); + } + match (self.control.len() - 1).checked_sub(depth as usize) { + Some(i) => { + let frame = &self.control[i]; + Ok((frame.block_type, frame.kind)) + } + None => bail_op_err!(offset, "unknown label: branch depth too large"), + } + } + + /// Validates that `memory_index` is valid in this module, and returns the + /// type of address used to index the memory specified. + fn check_memory_index(&self, offset: usize, memory_index: u32) -> Result { + if memory_index > 0 && !self.features.multi_memory { + bail_op_err!(offset, "multi-memory support is not enabled"); + } + match self.resources.memory_at(memory_index) { + Some(mem) => Ok(mem.index_type()), + None => bail_op_err!(offset, "unknown memory {}", memory_index), + } + } + + /// Validates a `memarg for alignment and such (also the memory it + /// references), and returns the type of index used to address the memory. + fn check_memarg( + &self, + memarg: MemoryImmediate, + max_align: u8, + offset: usize, + ) -> Result { + let index_ty = self.check_memory_index(offset, memarg.memory)?; + let align = memarg.align; + if align > max_align { + bail_op_err!(offset, "alignment must not be larger than natural"); + } + if index_ty == ValType::I32 && memarg.offset > u64::from(u32::MAX) { + bail_op_err!(offset, "offset out of range: must be <= 2**32"); + } + Ok(index_ty) + } + + #[cfg_attr(not(feature = "deterministic"), inline(always))] + fn check_non_deterministic_enabled(&self, offset: usize) -> Result<()> { + if cfg!(feature = "deterministic") && !self.features.deterministic_only { + bail_op_err!(offset, "deterministic_only support is not enabled"); + } + Ok(()) + } + + fn check_threads_enabled(&self, offset: usize) -> Result<()> { + if !self.features.threads { + bail_op_err!(offset, "threads support is not enabled") + } + Ok(()) + } + + fn check_reference_types_enabled(&self, offset: usize) -> Result<()> { + if !self.features.reference_types { + bail_op_err!(offset, "reference types support is not enabled") + } + Ok(()) + } + + /// Checks if Wasm proposal `saturating_float_to_int` is enabled. + fn check_saturating_float_to_int_enabled(&self, offset: usize) -> Result<()> { + if !self.features.saturating_float_to_int { + bail_op_err!( + offset, + "saturating float to int conversions support is not enabled" + ); + } + Ok(()) + } + + /// Checks if Wasm proposal `sign_extension` is enabled. + fn check_sign_extension_enabled(&self, offset: usize) -> Result<()> { + if !self.features.sign_extension { + bail_op_err!(offset, "sign extension operations support is not enabled"); + } + Ok(()) + } + + fn check_simd_enabled(&self, offset: usize) -> Result<()> { + if !self.features.simd { + bail_op_err!(offset, "SIMD support is not enabled"); + } + Ok(()) + } + + fn check_relaxed_simd_enabled(&self, offset: usize) -> Result<()> { + // Relaxed SIMD operators make sense only with SIMD and be non-deterministic. + self.check_non_deterministic_enabled(offset)?; + self.check_simd_enabled(offset)?; + if !self.features.relaxed_simd { + bail_op_err!(offset, "Relaxed SIMD support is not enabled"); + } + Ok(()) + } + + fn check_exceptions_enabled(&self, offset: usize) -> Result<()> { + if !self.features.exceptions { + bail_op_err!(offset, "Exceptions support is not enabled"); + } + Ok(()) + } + + fn check_bulk_memory_enabled(&self, offset: usize) -> Result<()> { + if !self.features.bulk_memory { + bail_op_err!(offset, "bulk memory support is not enabled"); + } + Ok(()) + } + + fn check_shared_memarg_wo_align( + &self, + offset: usize, + memarg: MemoryImmediate, + ) -> Result { + self.check_memory_index(offset, memarg.memory) + } + + fn check_simd_lane_index(&self, offset: usize, index: SIMDLaneIndex, max: u8) -> Result<()> { + if index >= max { + bail_op_err!(offset, "SIMD index out of bounds"); + } + Ok(()) + } + + /// Validates a block type, primarily with various in-flight proposals. + fn check_block_type(&self, offset: usize, ty: BlockType) -> Result<()> { + match ty { + BlockType::Empty => Ok(()), + BlockType::Type(ty) => self + .features + .check_value_type(ty) + .map_err(|e| BinaryReaderError::new(e, offset)), + BlockType::FuncType(idx) => { + if !self.features.multi_value { + bail_op_err!( + offset, + "blocks, loops, and ifs may only produce a resulttype \ + when multi-value is not enabled", + ); + } + self.func_type_at(idx, offset)?; + Ok(()) + } + } + } + + /// Validates a `call` instruction, ensuring that the function index is + /// in-bounds and the right types are on the stack to call the function. + fn check_call(&mut self, offset: usize, function_index: u32) -> Result<()> { + let ty = match self.resources.type_of_function(function_index) { + Some(i) => i, + None => { + bail_op_err!( + offset, + "unknown function {}: function index out of bounds", + function_index + ); + } + }; + for ty in ty.inputs().rev() { + self.pop_operand(offset, Some(ty))?; + } + for ty in ty.outputs() { + self.push_operand(ty)?; + } + Ok(()) + } + + /// Validates a call to an indirect function, very similar to `check_call`. + fn check_call_indirect(&mut self, offset: usize, index: u32, table_index: u32) -> Result<()> { + match self.resources.table_at(table_index) { + None => { + bail_op_err!(offset, "unknown table: table index out of bounds"); + } + Some(tab) => { + if tab.element_type != ValType::FuncRef { + bail_op_err!(offset, "indirect calls must go through a table of funcref"); + } + } + } + let ty = self.func_type_at(index, offset)?; + self.pop_operand(offset, Some(ValType::I32))?; + for ty in ty.inputs().rev() { + self.pop_operand(offset, Some(ty))?; + } + for ty in ty.outputs() { + self.push_operand(ty)?; + } + Ok(()) + } + + /// Validates a `return` instruction, popping types from the operand + /// stack that the function needs. + fn check_return(&mut self, offset: usize) -> Result<()> { + if self.control.is_empty() { + return Err(self.err_beyond_end(offset)); + } + for ty in self.results(offset, self.control[0].block_type)?.rev() { + self.pop_operand(offset, Some(ty))?; + } + self.unreachable(offset)?; + Ok(()) + } + + /// Checks the validity of a common comparison operator. + fn check_cmp_op(&mut self, offset: usize, ty: ValType) -> Result<()> { + self.pop_operand(offset, Some(ty))?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::I32)?; + Ok(()) + } + + /// Checks the validity of a common float comparison operator. + fn check_fcmp_op(&mut self, offset: usize, ty: ValType) -> Result<()> { + debug_assert!(matches!(ty, ValType::F32 | ValType::F64)); + self.check_non_deterministic_enabled(offset)?; + self.check_cmp_op(offset, ty) + } + + /// Checks the validity of a common unary operator. + fn check_unary_op(&mut self, offset: usize, ty: ValType) -> Result<()> { + self.pop_operand(offset, Some(ty))?; + self.push_operand(ty)?; + Ok(()) + } + + /// Checks the validity of a common unary float operator. + fn check_funary_op(&mut self, offset: usize, ty: ValType) -> Result<()> { + debug_assert!(matches!(ty, ValType::F32 | ValType::F64)); + self.check_non_deterministic_enabled(offset)?; + self.check_unary_op(offset, ty) + } + + /// Checks the validity of a common conversion operator. + fn check_conversion_op(&mut self, offset: usize, into: ValType, from: ValType) -> Result<()> { + self.pop_operand(offset, Some(from))?; + self.push_operand(into)?; + Ok(()) + } + + /// Checks the validity of a common conversion operator. + fn check_fconversion_op(&mut self, offset: usize, into: ValType, from: ValType) -> Result<()> { + debug_assert!(matches!(into, ValType::F32 | ValType::F64)); + self.check_non_deterministic_enabled(offset)?; + self.check_conversion_op(offset, into, from) + } + + /// Checks the validity of a common binary operator. + fn check_binary_op(&mut self, offset: usize, ty: ValType) -> Result<()> { + self.pop_operand(offset, Some(ty))?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ty)?; + Ok(()) + } + + /// Checks the validity of a common binary float operator. + fn check_fbinary_op(&mut self, offset: usize, ty: ValType) -> Result<()> { + debug_assert!(matches!(ty, ValType::F32 | ValType::F64)); + self.check_non_deterministic_enabled(offset)?; + self.check_binary_op(offset, ty) + } + + /// Checks the validity of an atomic load operator. + fn check_atomic_load( + &mut self, + offset: usize, + memarg: MemoryImmediate, + load_ty: ValType, + ) -> Result<()> { + self.check_threads_enabled(offset)?; + let ty = self.check_shared_memarg_wo_align(offset, memarg)?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(load_ty)?; + Ok(()) + } + + /// Checks the validity of an atomic store operator. + fn check_atomic_store( + &mut self, + offset: usize, + memarg: MemoryImmediate, + store_ty: ValType, + ) -> Result<()> { + self.check_threads_enabled(offset)?; + let ty = self.check_shared_memarg_wo_align(offset, memarg)?; + self.pop_operand(offset, Some(store_ty))?; + self.pop_operand(offset, Some(ty))?; + Ok(()) + } + + /// Checks the validity of a common atomic binary operator. + fn check_atomic_binary_op( + &mut self, + offset: usize, + memarg: MemoryImmediate, + op_ty: ValType, + ) -> Result<()> { + self.check_threads_enabled(offset)?; + let ty = self.check_shared_memarg_wo_align(offset, memarg)?; + self.pop_operand(offset, Some(op_ty))?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(op_ty)?; + Ok(()) + } + + /// Checks the validity of an atomic compare exchange operator. + fn check_atomic_binary_cmpxchg( + &mut self, + offset: usize, + memarg: MemoryImmediate, + op_ty: ValType, + ) -> Result<()> { + self.check_threads_enabled(offset)?; + let ty = self.check_shared_memarg_wo_align(offset, memarg)?; + self.pop_operand(offset, Some(op_ty))?; + self.pop_operand(offset, Some(op_ty))?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(op_ty)?; + Ok(()) + } + + /// Checks a [`V128`] splat operator. + fn check_v128_splat(&mut self, offset: usize, src_ty: ValType) -> Result<()> { + self.check_simd_enabled(offset)?; + self.pop_operand(offset, Some(src_ty))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + + /// Checks a [`V128`] binary operator. + fn check_v128_binary_op(&mut self, offset: usize) -> Result<()> { + self.check_simd_enabled(offset)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + + /// Checks a [`V128`] binary float operator. + fn check_v128_fbinary_op(&mut self, offset: usize) -> Result<()> { + self.check_non_deterministic_enabled(offset)?; + self.check_v128_binary_op(offset) + } + + /// Checks a [`V128`] binary operator. + fn check_v128_relaxed_binary_op(&mut self, offset: usize) -> Result<()> { + self.check_relaxed_simd_enabled(offset)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + + /// Checks a [`V128`] binary operator. + fn check_v128_unary_op(&mut self, offset: usize) -> Result<()> { + self.check_simd_enabled(offset)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + + /// Checks a [`V128`] binary operator. + fn check_v128_funary_op(&mut self, offset: usize) -> Result<()> { + self.check_non_deterministic_enabled(offset)?; + self.check_v128_unary_op(offset) + } + + /// Checks a [`V128`] binary operator. + fn check_v128_relaxed_unary_op(&mut self, offset: usize) -> Result<()> { + self.check_relaxed_simd_enabled(offset)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + + /// Checks a [`V128`] relaxed ternary operator. + fn check_v128_relaxed_ternary_op(&mut self, offset: usize) -> Result<()> { + self.check_relaxed_simd_enabled(offset)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + + /// Checks a [`V128`] relaxed ternary operator. + fn check_v128_bitmask_op(&mut self, offset: usize) -> Result<()> { + self.check_simd_enabled(offset)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::I32)?; + Ok(()) + } + + /// Checks a [`V128`] relaxed ternary operator. + fn check_v128_shift_op(&mut self, offset: usize) -> Result<()> { + self.check_simd_enabled(offset)?; + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + + /// Checks a [`V128`] common load operator. + fn check_v128_load_op(&mut self, offset: usize, memarg: MemoryImmediate) -> Result<()> { + self.check_simd_enabled(offset)?; + let idx = self.check_memarg(memarg, 3, offset)?; + self.pop_operand(offset, Some(idx))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + + fn func_type_at(&self, at: u32, offset: usize) -> Result<&'resources R::FuncType> { + self.resources + .func_type_at(at) + .ok_or_else(|| format_op_err!(offset, "unknown type: type index out of bounds")) + } + + fn tag_at(&self, at: u32, offset: usize) -> Result<&'resources R::FuncType> { + self.resources + .tag_at(at) + .ok_or_else(|| format_op_err!(offset, "unknown tag {}: tag index out of bounds", at)) + } + + fn params( + &self, + offset: usize, + ty: BlockType, + ) -> Result + 'resources> { + Ok(match ty { + BlockType::Empty | BlockType::Type(_) => Either::B(None.into_iter()), + BlockType::FuncType(t) => Either::A(self.func_type_at(t, offset)?.inputs()), + }) + } + + fn results( + &self, + offset: usize, + ty: BlockType, + ) -> Result + 'resources> { + Ok(match ty { + BlockType::Empty => Either::B(None.into_iter()), + BlockType::Type(t) => Either::B(Some(t).into_iter()), + BlockType::FuncType(t) => Either::A(self.func_type_at(t, offset)?.outputs()), + }) + } + + fn label_types( + &self, + offset: usize, + ty: BlockType, + kind: FrameKind, + ) -> Result + 'resources> { + Ok(match kind { + FrameKind::Loop => Either::A(self.params(offset, ty)?), + _ => Either::B(self.results(offset, ty)?), + }) + } +} + +fn ty_to_str(ty: ValType) -> &'static str { + match ty { + ValType::I32 => "i32", + ValType::I64 => "i64", + ValType::F32 => "f32", + ValType::F64 => "f64", + ValType::V128 => "v128", + ValType::FuncRef => "funcref", + ValType::ExternRef => "externref", + } +} + +impl<'a, T> VisitOperator<'a> for OperatorValidatorTemp<'_, '_, T> +where + T: WasmModuleResources, +{ + type Output = Result<()>; + + fn visit_nop(&mut self, _: usize) -> Self::Output { + Ok(()) + } + fn visit_unreachable(&mut self, offset: usize) -> Self::Output { + self.unreachable(offset)?; + Ok(()) + } + fn visit_block(&mut self, offset: usize, ty: BlockType) -> Self::Output { + self.check_block_type(offset, ty)?; + for ty in self.params(offset, ty)?.rev() { + self.pop_operand(offset, Some(ty))?; + } + self.push_ctrl(offset, FrameKind::Block, ty)?; + Ok(()) + } + fn visit_loop(&mut self, offset: usize, ty: BlockType) -> Self::Output { + self.check_block_type(offset, ty)?; + for ty in self.params(offset, ty)?.rev() { + self.pop_operand(offset, Some(ty))?; + } + self.push_ctrl(offset, FrameKind::Loop, ty)?; + Ok(()) + } + fn visit_if(&mut self, offset: usize, ty: BlockType) -> Self::Output { + self.check_block_type(offset, ty)?; + self.pop_operand(offset, Some(ValType::I32))?; + for ty in self.params(offset, ty)?.rev() { + self.pop_operand(offset, Some(ty))?; + } + self.push_ctrl(offset, FrameKind::If, ty)?; + Ok(()) + } + fn visit_else(&mut self, offset: usize) -> Self::Output { + let frame = self.pop_ctrl(offset)?; + if frame.kind != FrameKind::If { + bail_op_err!(offset, "else found outside of an `if` block"); + } + self.push_ctrl(offset, FrameKind::Else, frame.block_type)?; + Ok(()) + } + fn visit_try(&mut self, offset: usize, ty: BlockType) -> Self::Output { + self.check_exceptions_enabled(offset)?; + self.check_block_type(offset, ty)?; + for ty in self.params(offset, ty)?.rev() { + self.pop_operand(offset, Some(ty))?; + } + self.push_ctrl(offset, FrameKind::Try, ty)?; + Ok(()) + } + fn visit_catch(&mut self, offset: usize, index: u32) -> Self::Output { + self.check_exceptions_enabled(offset)?; + let frame = self.pop_ctrl(offset)?; + if frame.kind != FrameKind::Try && frame.kind != FrameKind::Catch { + bail_op_err!(offset, "catch found outside of an `try` block"); + } + // Start a new frame and push `exnref` value. + let height = self.operands.len(); + self.control.push(Frame { + kind: FrameKind::Catch, + block_type: frame.block_type, + height, + unreachable: false, + }); + // Push exception argument types. + let ty = self.tag_at(index, offset)?; + for ty in ty.inputs() { + self.push_operand(ty)?; + } + Ok(()) + } + fn visit_throw(&mut self, offset: usize, index: u32) -> Self::Output { + self.check_exceptions_enabled(offset)?; + // Check values associated with the exception. + let ty = self.tag_at(index, offset)?; + for ty in ty.inputs().rev() { + self.pop_operand(offset, Some(ty))?; + } + if ty.outputs().len() > 0 { + bail_op_err!(offset, "result type expected to be empty for exception"); + } + self.unreachable(offset)?; + Ok(()) + } + fn visit_rethrow(&mut self, offset: usize, relative_depth: u32) -> Self::Output { + self.check_exceptions_enabled(offset)?; + // This is not a jump, but we need to check that the `rethrow` + // targets an actual `catch` to get the exception. + let (_, kind) = self.jump(offset, relative_depth)?; + if kind != FrameKind::Catch && kind != FrameKind::CatchAll { + bail_op_err!( + offset, + "invalid rethrow label: target was not a `catch` block" + ); + } + self.unreachable(offset)?; + Ok(()) + } + fn visit_delegate(&mut self, offset: usize, relative_depth: u32) -> Self::Output { + self.check_exceptions_enabled(offset)?; + let frame = self.pop_ctrl(offset)?; + if frame.kind != FrameKind::Try { + bail_op_err!(offset, "delegate found outside of an `try` block"); + } + // This operation is not a jump, but we need to check the + // depth for validity + let _ = self.jump(offset, relative_depth)?; + for ty in self.results(offset, frame.block_type)? { + self.push_operand(ty)?; + } + Ok(()) + } + fn visit_catch_all(&mut self, offset: usize) -> Self::Output { + self.check_exceptions_enabled(offset)?; + let frame = self.pop_ctrl(offset)?; + if frame.kind == FrameKind::CatchAll { + bail_op_err!(offset, "only one catch_all allowed per `try` block"); + } else if frame.kind != FrameKind::Try && frame.kind != FrameKind::Catch { + bail_op_err!(offset, "catch_all found outside of a `try` block"); + } + let height = self.operands.len(); + self.control.push(Frame { + kind: FrameKind::CatchAll, + block_type: frame.block_type, + height, + unreachable: false, + }); + Ok(()) + } + fn visit_end(&mut self, offset: usize) -> Self::Output { + let mut frame = self.pop_ctrl(offset)?; + + // Note that this `if` isn't included in the appendix right + // now, but it's used to allow for `if` statements that are + // missing an `else` block which have the same parameter/return + // types on the block (since that's valid). + if frame.kind == FrameKind::If { + self.push_ctrl(offset, FrameKind::Else, frame.block_type)?; + frame = self.pop_ctrl(offset)?; + } + for ty in self.results(offset, frame.block_type)? { + self.push_operand(ty)?; + } + + if self.control.is_empty() && self.end_which_emptied_control.is_none() { + self.end_which_emptied_control = Some(offset); + } + Ok(()) + } + fn visit_br(&mut self, offset: usize, relative_depth: u32) -> Self::Output { + let (ty, kind) = self.jump(offset, relative_depth)?; + for ty in self.label_types(offset, ty, kind)?.rev() { + self.pop_operand(offset, Some(ty))?; + } + self.unreachable(offset)?; + Ok(()) + } + fn visit_br_if(&mut self, offset: usize, relative_depth: u32) -> Self::Output { + self.pop_operand(offset, Some(ValType::I32))?; + let (ty, kind) = self.jump(offset, relative_depth)?; + for ty in self.label_types(offset, ty, kind)?.rev() { + self.pop_operand(offset, Some(ty))?; + } + for ty in self.label_types(offset, ty, kind)? { + self.push_operand(ty)?; + } + Ok(()) + } + fn visit_br_table(&mut self, offset: usize, table: &BrTable) -> Self::Output { + self.pop_operand(offset, Some(ValType::I32))?; + let default = self.jump(offset, table.default())?; + let default_types = self.label_types(offset, default.0, default.1)?; + for element in table.targets() { + let relative_depth = element?; + let block = self.jump(offset, relative_depth)?; + let tys = self.label_types(offset, block.0, block.1)?; + if tys.len() != default_types.len() { + bail_op_err!( + offset, + "type mismatch: br_table target labels have different number of types" + ); + } + debug_assert!(self.br_table_tmp.is_empty()); + for ty in tys.rev() { + let ty = self.pop_operand(offset, Some(ty))?; + self.br_table_tmp.push(ty); + } + for ty in self.inner.br_table_tmp.drain(..).rev() { + self.inner.operands.push(ty); + } + } + for ty in default_types.rev() { + self.pop_operand(offset, Some(ty))?; + } + self.unreachable(offset)?; + Ok(()) + } + fn visit_return(&mut self, offset: usize) -> Self::Output { + self.check_return(offset)?; + Ok(()) + } + fn visit_call(&mut self, offset: usize, function_index: u32) -> Self::Output { + self.check_call(offset, function_index)?; + Ok(()) + } + fn visit_return_call(&mut self, offset: usize, function_index: u32) -> Self::Output { + if !self.features.tail_call { + bail_op_err!(offset, "tail calls support is not enabled"); + } + self.check_call(offset, function_index)?; + self.check_return(offset)?; + Ok(()) + } + fn visit_call_indirect( + &mut self, + offset: usize, + index: u32, + table_index: u32, + table_byte: u8, + ) -> Self::Output { + if table_byte != 0 && !self.features.reference_types { + bail_op_err!(offset, "reference-types not enabled: zero byte expected"); + } + self.check_call_indirect(offset, index, table_index)?; + Ok(()) + } + fn visit_return_call_indirect( + &mut self, + offset: usize, + index: u32, + table_index: u32, + ) -> Self::Output { + if !self.features.tail_call { + bail_op_err!(offset, "tail calls support is not enabled"); + } + self.check_call_indirect(offset, index, table_index)?; + self.check_return(offset)?; + Ok(()) + } + fn visit_drop(&mut self, offset: usize) -> Self::Output { + self.pop_operand(offset, None)?; + Ok(()) + } + fn visit_select(&mut self, offset: usize) -> Self::Output { + self.pop_operand(offset, Some(ValType::I32))?; + let ty1 = self.pop_operand(offset, None)?; + let ty2 = self.pop_operand(offset, None)?; + fn is_num(ty: Option) -> bool { + matches!( + ty, + Some(ValType::I32) + | Some(ValType::I64) + | Some(ValType::F32) + | Some(ValType::F64) + | Some(ValType::V128) + | None + ) + } + if !is_num(ty1) || !is_num(ty2) { + bail_op_err!(offset, "type mismatch: select only takes integral types") + } + if ty1 != ty2 && ty1 != None && ty2 != None { + bail_op_err!( + offset, + "type mismatch: select operands have different types" + ) + } + self.push_operand(ty1.or(ty2))?; + Ok(()) + } + fn visit_typed_select(&mut self, offset: usize, ty: ValType) -> Self::Output { + self.features + .check_value_type(ty) + .map_err(|e| BinaryReaderError::new(e, offset))?; + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ty))?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ty)?; + Ok(()) + } + fn visit_local_get(&mut self, offset: usize, local_index: u32) -> Self::Output { + let ty = self.local(offset, local_index)?; + self.push_operand(ty)?; + Ok(()) + } + fn visit_local_set(&mut self, offset: usize, local_index: u32) -> Self::Output { + let ty = self.local(offset, local_index)?; + self.pop_operand(offset, Some(ty))?; + Ok(()) + } + fn visit_local_tee(&mut self, offset: usize, local_index: u32) -> Self::Output { + let ty = self.local(offset, local_index)?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ty)?; + Ok(()) + } + fn visit_global_get(&mut self, offset: usize, global_index: u32) -> Self::Output { + if let Some(ty) = self.resources.global_at(global_index) { + self.push_operand(ty.content_type)?; + } else { + bail_op_err!(offset, "unknown global: global index out of bounds"); + }; + Ok(()) + } + fn visit_global_set(&mut self, offset: usize, global_index: u32) -> Self::Output { + if let Some(ty) = self.resources.global_at(global_index) { + if !ty.mutable { + bail_op_err!( + offset, + "global is immutable: cannot modify it with `global.set`" + ); + } + self.pop_operand(offset, Some(ty.content_type))?; + } else { + bail_op_err!(offset, "unknown global: global index out of bounds"); + }; + Ok(()) + } + fn visit_i32_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + let ty = self.check_memarg(memarg, 2, offset)?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::I32)?; + Ok(()) + } + fn visit_i64_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + let ty = self.check_memarg(memarg, 3, offset)?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::I64)?; + Ok(()) + } + fn visit_f32_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_non_deterministic_enabled(offset)?; + let ty = self.check_memarg(memarg, 2, offset)?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::F32)?; + Ok(()) + } + fn visit_f64_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_non_deterministic_enabled(offset)?; + let ty = self.check_memarg(memarg, 3, offset)?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::F64)?; + Ok(()) + } + fn visit_i32_load8_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + let ty = self.check_memarg(memarg, 0, offset)?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::I32)?; + Ok(()) + } + fn visit_i32_load8_u(&mut self, input: usize, memarg: MemoryImmediate) -> Self::Output { + self.visit_i32_load8_s(input, memarg) + } + fn visit_i32_load16_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + let ty = self.check_memarg(memarg, 1, offset)?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::I32)?; + Ok(()) + } + fn visit_i32_load16_u(&mut self, input: usize, memarg: MemoryImmediate) -> Self::Output { + self.visit_i32_load16_s(input, memarg) + } + fn visit_i64_load8_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + let ty = self.check_memarg(memarg, 0, offset)?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::I64)?; + Ok(()) + } + fn visit_i64_load8_u(&mut self, input: usize, memarg: MemoryImmediate) -> Self::Output { + self.visit_i64_load8_s(input, memarg) + } + fn visit_i64_load16_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + let ty = self.check_memarg(memarg, 1, offset)?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::I64)?; + Ok(()) + } + fn visit_i64_load16_u(&mut self, input: usize, memarg: MemoryImmediate) -> Self::Output { + self.visit_i64_load16_s(input, memarg) + } + fn visit_i64_load32_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + let ty = self.check_memarg(memarg, 2, offset)?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::I64)?; + Ok(()) + } + fn visit_i64_load32_u(&mut self, input: usize, memarg: MemoryImmediate) -> Self::Output { + self.visit_i64_load32_s(input, memarg) + } + fn visit_i32_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + let ty = self.check_memarg(memarg, 2, offset)?; + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ty))?; + Ok(()) + } + fn visit_i64_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + let ty = self.check_memarg(memarg, 3, offset)?; + self.pop_operand(offset, Some(ValType::I64))?; + self.pop_operand(offset, Some(ty))?; + Ok(()) + } + fn visit_f32_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_non_deterministic_enabled(offset)?; + let ty = self.check_memarg(memarg, 2, offset)?; + self.pop_operand(offset, Some(ValType::F32))?; + self.pop_operand(offset, Some(ty))?; + Ok(()) + } + fn visit_f64_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_non_deterministic_enabled(offset)?; + let ty = self.check_memarg(memarg, 3, offset)?; + self.pop_operand(offset, Some(ValType::F64))?; + self.pop_operand(offset, Some(ty))?; + Ok(()) + } + fn visit_i32_store8(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + let ty = self.check_memarg(memarg, 0, offset)?; + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ty))?; + Ok(()) + } + fn visit_i32_store16(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + let ty = self.check_memarg(memarg, 1, offset)?; + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ty))?; + Ok(()) + } + fn visit_i64_store8(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + let ty = self.check_memarg(memarg, 0, offset)?; + self.pop_operand(offset, Some(ValType::I64))?; + self.pop_operand(offset, Some(ty))?; + Ok(()) + } + fn visit_i64_store16(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + let ty = self.check_memarg(memarg, 1, offset)?; + self.pop_operand(offset, Some(ValType::I64))?; + self.pop_operand(offset, Some(ty))?; + Ok(()) + } + fn visit_i64_store32(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + let ty = self.check_memarg(memarg, 2, offset)?; + self.pop_operand(offset, Some(ValType::I64))?; + self.pop_operand(offset, Some(ty))?; + Ok(()) + } + fn visit_memory_size(&mut self, offset: usize, mem: u32, mem_byte: u8) -> Self::Output { + if mem_byte != 0 && !self.features.multi_memory { + bail_op_err!(offset, "multi-memory not enabled: zero byte expected"); + } + let index_ty = self.check_memory_index(offset, mem)?; + self.push_operand(index_ty)?; + Ok(()) + } + fn visit_memory_grow(&mut self, offset: usize, mem: u32, mem_byte: u8) -> Self::Output { + if mem_byte != 0 && !self.features.multi_memory { + bail_op_err!(offset, "multi-memory not enabled: zero byte expected"); + } + let index_ty = self.check_memory_index(offset, mem)?; + self.pop_operand(offset, Some(index_ty))?; + self.push_operand(index_ty)?; + Ok(()) + } + fn visit_i32_const(&mut self, _offset: usize, _value: i32) -> Self::Output { + self.push_operand(ValType::I32)?; + Ok(()) + } + fn visit_i64_const(&mut self, _offset: usize, _value: i64) -> Self::Output { + self.push_operand(ValType::I64)?; + Ok(()) + } + fn visit_f32_const(&mut self, offset: usize, _value: Ieee32) -> Self::Output { + self.check_non_deterministic_enabled(offset)?; + self.push_operand(ValType::F32)?; + Ok(()) + } + fn visit_f64_const(&mut self, offset: usize, _value: Ieee64) -> Self::Output { + self.check_non_deterministic_enabled(offset)?; + self.push_operand(ValType::F64)?; + Ok(()) + } + fn visit_i32_eqz(&mut self, offset: usize) -> Self::Output { + self.pop_operand(offset, Some(ValType::I32))?; + self.push_operand(ValType::I32)?; + Ok(()) + } + fn visit_i32_eq(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I32) + } + fn visit_i32_ne(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I32) + } + fn visit_i32_lt_s(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I32) + } + fn visit_i32_lt_u(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I32) + } + fn visit_i32_gt_s(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I32) + } + fn visit_i32_gt_u(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I32) + } + fn visit_i32_le_s(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I32) + } + fn visit_i32_le_u(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I32) + } + fn visit_i32_ge_s(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I32) + } + fn visit_i32_ge_u(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I32) + } + fn visit_i64_eqz(&mut self, offset: usize) -> Self::Output { + self.pop_operand(offset, Some(ValType::I64))?; + self.push_operand(ValType::I32)?; + Ok(()) + } + fn visit_i64_eq(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I64) + } + fn visit_i64_ne(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I64) + } + fn visit_i64_lt_s(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I64) + } + fn visit_i64_lt_u(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I64) + } + fn visit_i64_gt_s(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I64) + } + fn visit_i64_gt_u(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I64) + } + fn visit_i64_le_s(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I64) + } + fn visit_i64_le_u(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I64) + } + fn visit_i64_ge_s(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I64) + } + fn visit_i64_ge_u(&mut self, offset: usize) -> Self::Output { + self.check_cmp_op(offset, ValType::I64) + } + fn visit_f32_eq(&mut self, offset: usize) -> Self::Output { + self.check_fcmp_op(offset, ValType::F32) + } + fn visit_f32_ne(&mut self, offset: usize) -> Self::Output { + self.check_fcmp_op(offset, ValType::F32) + } + fn visit_f32_lt(&mut self, offset: usize) -> Self::Output { + self.check_fcmp_op(offset, ValType::F32) + } + fn visit_f32_gt(&mut self, offset: usize) -> Self::Output { + self.check_fcmp_op(offset, ValType::F32) + } + fn visit_f32_le(&mut self, offset: usize) -> Self::Output { + self.check_fcmp_op(offset, ValType::F32) + } + fn visit_f32_ge(&mut self, offset: usize) -> Self::Output { + self.check_fcmp_op(offset, ValType::F32) + } + fn visit_f64_eq(&mut self, offset: usize) -> Self::Output { + self.check_fcmp_op(offset, ValType::F64) + } + fn visit_f64_ne(&mut self, offset: usize) -> Self::Output { + self.check_fcmp_op(offset, ValType::F64) + } + fn visit_f64_lt(&mut self, offset: usize) -> Self::Output { + self.check_fcmp_op(offset, ValType::F64) + } + fn visit_f64_gt(&mut self, offset: usize) -> Self::Output { + self.check_fcmp_op(offset, ValType::F64) + } + fn visit_f64_le(&mut self, offset: usize) -> Self::Output { + self.check_fcmp_op(offset, ValType::F64) + } + fn visit_f64_ge(&mut self, offset: usize) -> Self::Output { + self.check_fcmp_op(offset, ValType::F64) + } + fn visit_i32_clz(&mut self, offset: usize) -> Self::Output { + self.check_unary_op(offset, ValType::I32) + } + fn visit_i32_ctz(&mut self, offset: usize) -> Self::Output { + self.check_unary_op(offset, ValType::I32) + } + fn visit_i32_popcnt(&mut self, offset: usize) -> Self::Output { + self.check_unary_op(offset, ValType::I32) + } + fn visit_i32_add(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_i32_sub(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_i32_mul(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_i32_div_s(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_i32_div_u(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_i32_rem_s(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_i32_rem_u(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_i32_and(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_i32_or(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_i32_xor(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_i32_shl(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_i32_shr_s(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_i32_shr_u(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_i32_rotl(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_i32_rotr(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_i64_clz(&mut self, offset: usize) -> Self::Output { + self.check_unary_op(offset, ValType::I64) + } + fn visit_i64_ctz(&mut self, offset: usize) -> Self::Output { + self.check_unary_op(offset, ValType::I64) + } + fn visit_i64_popcnt(&mut self, offset: usize) -> Self::Output { + self.check_unary_op(offset, ValType::I64) + } + fn visit_i64_add(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I64) + } + fn visit_i64_sub(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I64) + } + fn visit_i64_mul(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I64) + } + fn visit_i64_div_s(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I64) + } + fn visit_i64_div_u(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I64) + } + fn visit_i64_rem_s(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I64) + } + fn visit_i64_rem_u(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I64) + } + fn visit_i64_and(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I64) + } + fn visit_i64_or(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I64) + } + fn visit_i64_xor(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I64) + } + fn visit_i64_shl(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I64) + } + fn visit_i64_shr_s(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I64) + } + fn visit_i64_shr_u(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I64) + } + fn visit_i64_rotl(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I64) + } + fn visit_i64_rotr(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I64) + } + fn visit_f32_abs(&mut self, offset: usize) -> Self::Output { + self.check_funary_op(offset, ValType::F32) + } + fn visit_f32_neg(&mut self, offset: usize) -> Self::Output { + self.check_funary_op(offset, ValType::F32) + } + fn visit_f32_ceil(&mut self, offset: usize) -> Self::Output { + self.check_funary_op(offset, ValType::F32) + } + fn visit_f32_floor(&mut self, offset: usize) -> Self::Output { + self.check_funary_op(offset, ValType::F32) + } + fn visit_f32_trunc(&mut self, offset: usize) -> Self::Output { + self.check_funary_op(offset, ValType::F32) + } + fn visit_f32_nearest(&mut self, offset: usize) -> Self::Output { + self.check_funary_op(offset, ValType::F32) + } + fn visit_f32_sqrt(&mut self, offset: usize) -> Self::Output { + self.check_funary_op(offset, ValType::F32) + } + fn visit_f32_add(&mut self, offset: usize) -> Self::Output { + self.check_fbinary_op(offset, ValType::F32) + } + fn visit_f32_sub(&mut self, offset: usize) -> Self::Output { + self.check_fbinary_op(offset, ValType::F32) + } + fn visit_f32_mul(&mut self, offset: usize) -> Self::Output { + self.check_fbinary_op(offset, ValType::F32) + } + fn visit_f32_div(&mut self, offset: usize) -> Self::Output { + self.check_fbinary_op(offset, ValType::F32) + } + fn visit_f32_min(&mut self, offset: usize) -> Self::Output { + self.check_fbinary_op(offset, ValType::F32) + } + fn visit_f32_max(&mut self, offset: usize) -> Self::Output { + self.check_fbinary_op(offset, ValType::F32) + } + fn visit_f32_copysign(&mut self, offset: usize) -> Self::Output { + self.check_fbinary_op(offset, ValType::F32) + } + fn visit_f64_abs(&mut self, offset: usize) -> Self::Output { + self.check_funary_op(offset, ValType::F64) + } + fn visit_f64_neg(&mut self, offset: usize) -> Self::Output { + self.check_funary_op(offset, ValType::F64) + } + fn visit_f64_ceil(&mut self, offset: usize) -> Self::Output { + self.check_funary_op(offset, ValType::F64) + } + fn visit_f64_floor(&mut self, offset: usize) -> Self::Output { + self.check_funary_op(offset, ValType::F64) + } + fn visit_f64_trunc(&mut self, offset: usize) -> Self::Output { + self.check_funary_op(offset, ValType::F64) + } + fn visit_f64_nearest(&mut self, offset: usize) -> Self::Output { + self.check_funary_op(offset, ValType::F64) + } + fn visit_f64_sqrt(&mut self, offset: usize) -> Self::Output { + self.check_funary_op(offset, ValType::F64) + } + fn visit_f64_add(&mut self, offset: usize) -> Self::Output { + self.check_fbinary_op(offset, ValType::F64) + } + fn visit_f64_sub(&mut self, offset: usize) -> Self::Output { + self.check_fbinary_op(offset, ValType::F64) + } + fn visit_f64_mul(&mut self, offset: usize) -> Self::Output { + self.check_fbinary_op(offset, ValType::F64) + } + fn visit_f64_div(&mut self, offset: usize) -> Self::Output { + self.check_fbinary_op(offset, ValType::F64) + } + fn visit_f64_min(&mut self, offset: usize) -> Self::Output { + self.check_fbinary_op(offset, ValType::F64) + } + fn visit_f64_max(&mut self, offset: usize) -> Self::Output { + self.check_fbinary_op(offset, ValType::F64) + } + fn visit_f64_copysign(&mut self, offset: usize) -> Self::Output { + self.check_fbinary_op(offset, ValType::F64) + } + fn visit_i32_wrap_i64(&mut self, offset: usize) -> Self::Output { + self.check_conversion_op(offset, ValType::I32, ValType::I64) + } + fn visit_i32_trunc_f32s(&mut self, offset: usize) -> Self::Output { + self.check_conversion_op(offset, ValType::I32, ValType::F32) + } + fn visit_i32_trunc_f32u(&mut self, offset: usize) -> Self::Output { + self.check_conversion_op(offset, ValType::I32, ValType::F32) + } + fn visit_i32_trunc_f64s(&mut self, offset: usize) -> Self::Output { + self.check_conversion_op(offset, ValType::I32, ValType::F64) + } + fn visit_i32_trunc_f64u(&mut self, offset: usize) -> Self::Output { + self.check_conversion_op(offset, ValType::I32, ValType::F64) + } + fn visit_i64_extend_i32s(&mut self, offset: usize) -> Self::Output { + self.check_conversion_op(offset, ValType::I64, ValType::I32) + } + fn visit_i64_extend_i32u(&mut self, offset: usize) -> Self::Output { + self.check_conversion_op(offset, ValType::I64, ValType::I32) + } + fn visit_i64_trunc_f32s(&mut self, offset: usize) -> Self::Output { + self.check_conversion_op(offset, ValType::I64, ValType::F32) + } + fn visit_i64_trunc_f32u(&mut self, offset: usize) -> Self::Output { + self.check_conversion_op(offset, ValType::I64, ValType::F32) + } + fn visit_i64_trunc_f64s(&mut self, offset: usize) -> Self::Output { + self.check_conversion_op(offset, ValType::I64, ValType::F64) + } + fn visit_i64_trunc_f64u(&mut self, offset: usize) -> Self::Output { + self.check_conversion_op(offset, ValType::I64, ValType::F64) + } + fn visit_f32_convert_i32s(&mut self, offset: usize) -> Self::Output { + self.check_fconversion_op(offset, ValType::F32, ValType::I32) + } + fn visit_f32_convert_i32u(&mut self, offset: usize) -> Self::Output { + self.check_fconversion_op(offset, ValType::F32, ValType::I32) + } + fn visit_f32_convert_i64s(&mut self, offset: usize) -> Self::Output { + self.check_fconversion_op(offset, ValType::F32, ValType::I64) + } + fn visit_f32_convert_i64u(&mut self, offset: usize) -> Self::Output { + self.check_fconversion_op(offset, ValType::F32, ValType::I64) + } + fn visit_f32_demote_f64(&mut self, offset: usize) -> Self::Output { + self.check_fconversion_op(offset, ValType::F32, ValType::F64) + } + fn visit_f64_convert_i32s(&mut self, offset: usize) -> Self::Output { + self.check_fconversion_op(offset, ValType::F64, ValType::I32) + } + fn visit_f64_convert_i32u(&mut self, offset: usize) -> Self::Output { + self.check_fconversion_op(offset, ValType::F64, ValType::I32) + } + fn visit_f64_convert_i64s(&mut self, offset: usize) -> Self::Output { + self.check_fconversion_op(offset, ValType::F64, ValType::I64) + } + fn visit_f64_convert_i64u(&mut self, offset: usize) -> Self::Output { + self.check_fconversion_op(offset, ValType::F64, ValType::I64) + } + fn visit_f64_promote_f32(&mut self, offset: usize) -> Self::Output { + self.check_fconversion_op(offset, ValType::F64, ValType::F32) + } + fn visit_i32_reinterpret_f32(&mut self, offset: usize) -> Self::Output { + self.check_conversion_op(offset, ValType::I32, ValType::F32) + } + fn visit_i64_reinterpret_f64(&mut self, offset: usize) -> Self::Output { + self.check_conversion_op(offset, ValType::I64, ValType::F64) + } + fn visit_f32_reinterpret_i32(&mut self, offset: usize) -> Self::Output { + self.check_fconversion_op(offset, ValType::F32, ValType::I32) + } + fn visit_f64_reinterpret_i64(&mut self, offset: usize) -> Self::Output { + self.check_fconversion_op(offset, ValType::F64, ValType::I64) + } + fn visit_i32_trunc_sat_f32s(&mut self, offset: usize) -> Self::Output { + self.check_saturating_float_to_int_enabled(offset)?; + self.check_conversion_op(offset, ValType::I32, ValType::F32) + } + fn visit_i32_trunc_sat_f32u(&mut self, offset: usize) -> Self::Output { + self.check_saturating_float_to_int_enabled(offset)?; + self.check_conversion_op(offset, ValType::I32, ValType::F32) + } + fn visit_i32_trunc_sat_f64s(&mut self, offset: usize) -> Self::Output { + self.check_saturating_float_to_int_enabled(offset)?; + self.check_conversion_op(offset, ValType::I32, ValType::F64) + } + fn visit_i32_trunc_sat_f64u(&mut self, offset: usize) -> Self::Output { + self.check_saturating_float_to_int_enabled(offset)?; + self.check_conversion_op(offset, ValType::I32, ValType::F64) + } + fn visit_i64_trunc_sat_f32s(&mut self, offset: usize) -> Self::Output { + self.check_saturating_float_to_int_enabled(offset)?; + self.check_conversion_op(offset, ValType::I64, ValType::F32) + } + fn visit_i64_trunc_sat_f32u(&mut self, offset: usize) -> Self::Output { + self.check_saturating_float_to_int_enabled(offset)?; + self.check_conversion_op(offset, ValType::I64, ValType::F32) + } + fn visit_i64_trunc_sat_f64s(&mut self, offset: usize) -> Self::Output { + self.check_saturating_float_to_int_enabled(offset)?; + self.check_conversion_op(offset, ValType::I64, ValType::F64) + } + fn visit_i64_trunc_sat_f64u(&mut self, offset: usize) -> Self::Output { + self.check_saturating_float_to_int_enabled(offset)?; + self.check_conversion_op(offset, ValType::I64, ValType::F64) + } + fn visit_i32_extend8_s(&mut self, offset: usize) -> Self::Output { + self.check_sign_extension_enabled(offset)?; + self.check_unary_op(offset, ValType::I32) + } + fn visit_i32_extend16_s(&mut self, offset: usize) -> Self::Output { + self.check_sign_extension_enabled(offset)?; + self.check_unary_op(offset, ValType::I32) + } + fn visit_i64_extend8_s(&mut self, offset: usize) -> Self::Output { + self.check_sign_extension_enabled(offset)?; + self.check_unary_op(offset, ValType::I64) + } + fn visit_i64_extend16_s(&mut self, offset: usize) -> Self::Output { + self.check_sign_extension_enabled(offset)?; + self.check_unary_op(offset, ValType::I64) + } + fn visit_i64_extend32_s(&mut self, offset: usize) -> Self::Output { + self.check_sign_extension_enabled(offset)?; + self.check_unary_op(offset, ValType::I64) + } + fn visit_i32_atomic_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_load(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_load16_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_load(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_load8_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_load(offset, memarg, ValType::I32) + } + fn visit_i64_atomic_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_load(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_load32_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_load(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_load16_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_load(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_load8_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_load(offset, memarg, ValType::I64) + } + fn visit_i32_atomic_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_store(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_store16(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_store(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_store8(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_store(offset, memarg, ValType::I32) + } + fn visit_i64_atomic_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_store(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_store32(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_store(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_store16(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_store(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_store8(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_store(offset, memarg, ValType::I64) + } + fn visit_i32_atomic_rmw_add(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw_sub(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw_and(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw_or(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw_xor(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw16_add_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw16_sub_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw16_and_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw16_or_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw16_xor_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw8_add_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw8_sub_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw8_and_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw8_or_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw8_xor_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i64_atomic_rmw_add(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw_sub(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw_and(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw_or(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw_xor(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw32_add_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw32_sub_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw32_and_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw32_or_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw32_xor_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw16_add_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw16_sub_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw16_and_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw16_or_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw16_xor_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw8_add_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw8_sub_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw8_and_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw8_or_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw8_xor_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i32_atomic_rmw_xchg( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw16_xchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw8_xchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw_cmpxchg( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_cmpxchg(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw16_cmpxchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_cmpxchg(offset, memarg, ValType::I32) + } + fn visit_i32_atomic_rmw8_cmpxchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_cmpxchg(offset, memarg, ValType::I32) + } + fn visit_i64_atomic_rmw_xchg( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw32_xchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw16_xchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw8_xchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw_cmpxchg( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_cmpxchg(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw32_cmpxchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_cmpxchg(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw16_cmpxchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_cmpxchg(offset, memarg, ValType::I64) + } + fn visit_i64_atomic_rmw8_cmpxchg_u( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_cmpxchg(offset, memarg, ValType::I64) + } + fn visit_memory_atomic_notify( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_atomic_binary_op(offset, memarg, ValType::I32) + } + fn visit_memory_atomic_wait32( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_threads_enabled(offset)?; + let ty = self.check_shared_memarg_wo_align(offset, memarg)?; + self.pop_operand(offset, Some(ValType::I64))?; + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::I32)?; + Ok(()) + } + fn visit_memory_atomic_wait64( + &mut self, + offset: usize, + memarg: MemoryImmediate, + ) -> Self::Output { + self.check_threads_enabled(offset)?; + let ty = self.check_shared_memarg_wo_align(offset, memarg)?; + self.pop_operand(offset, Some(ValType::I64))?; + self.pop_operand(offset, Some(ValType::I64))?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::I32)?; + Ok(()) + } + fn visit_atomic_fence(&mut self, offset: usize, flags: u8) -> Self::Output { + self.check_threads_enabled(offset)?; + if flags != 0 { + bail_op_err!(offset, "non-zero flags for fence not supported yet"); + } + Ok(()) + } + fn visit_ref_null(&mut self, offset: usize, ty: ValType) -> Self::Output { + self.check_reference_types_enabled(offset)?; + self.features + .check_value_type(ty) + .map_err(|e| BinaryReaderError::new(e, offset))?; + if !ty.is_reference_type() { + bail_op_err!(offset, "invalid non-reference type in ref.null"); + } + self.push_operand(ty)?; + Ok(()) + } + fn visit_ref_is_null(&mut self, offset: usize) -> Self::Output { + self.check_reference_types_enabled(offset)?; + match self.pop_operand(offset, None)? { + None => {} + Some(t) => { + if !t.is_reference_type() { + bail_op_err!( + offset, + "type mismatch: invalid reference type in ref.is_null" + ); + } + } + } + self.push_operand(ValType::I32)?; + Ok(()) + } + fn visit_ref_func(&mut self, offset: usize, function_index: u32) -> Self::Output { + self.check_reference_types_enabled(offset)?; + if self.resources.type_of_function(function_index).is_none() { + bail_op_err!( + offset, + "unknown function {}: function index out of bounds", + function_index, + ); + } + if !self.resources.is_function_referenced(function_index) { + bail_op_err!(offset, "undeclared function reference"); + } + self.push_operand(ValType::FuncRef)?; + Ok(()) + } + fn visit_v128_load(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_simd_enabled(offset)?; + let ty = self.check_memarg(memarg, 4, offset)?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_v128_store(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_simd_enabled(offset)?; + let ty = self.check_memarg(memarg, 4, offset)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(ty))?; + Ok(()) + } + fn visit_v128_const(&mut self, offset: usize, _value: V128) -> Self::Output { + self.check_simd_enabled(offset)?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_i8x16_splat(&mut self, offset: usize) -> Self::Output { + self.check_v128_splat(offset, ValType::I32) + } + fn visit_i16x8_splat(&mut self, offset: usize) -> Self::Output { + self.check_v128_splat(offset, ValType::I32) + } + fn visit_i32x4_splat(&mut self, offset: usize) -> Self::Output { + self.check_v128_splat(offset, ValType::I32) + } + fn visit_i64x2_splat(&mut self, offset: usize) -> Self::Output { + self.check_v128_splat(offset, ValType::I64) + } + fn visit_f32x4_splat(&mut self, offset: usize) -> Self::Output { + self.check_non_deterministic_enabled(offset)?; + self.check_v128_splat(offset, ValType::F32) + } + fn visit_f64x2_splat(&mut self, offset: usize) -> Self::Output { + self.check_non_deterministic_enabled(offset)?; + self.check_v128_splat(offset, ValType::F64) + } + fn visit_i8x16_extract_lane_s(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { + self.check_simd_enabled(offset)?; + self.check_simd_lane_index(offset, lane, 16)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::I32)?; + Ok(()) + } + fn visit_i8x16_extract_lane_u(&mut self, input: usize, lane: SIMDLaneIndex) -> Self::Output { + self.visit_i8x16_extract_lane_s(input, lane) + } + fn visit_i16x8_extract_lane_s(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { + self.check_simd_enabled(offset)?; + self.check_simd_lane_index(offset, lane, 8)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::I32)?; + Ok(()) + } + fn visit_i16x8_extract_lane_u(&mut self, input: usize, lane: SIMDLaneIndex) -> Self::Output { + self.visit_i16x8_extract_lane_s(input, lane) + } + fn visit_i32x4_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { + self.check_simd_enabled(offset)?; + self.check_simd_lane_index(offset, lane, 4)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::I32)?; + Ok(()) + } + fn visit_i8x16_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { + self.check_simd_enabled(offset)?; + self.check_simd_lane_index(offset, lane, 16)?; + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_i16x8_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { + self.check_simd_enabled(offset)?; + self.check_simd_lane_index(offset, lane, 8)?; + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_i32x4_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { + self.check_simd_enabled(offset)?; + self.check_simd_lane_index(offset, lane, 4)?; + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_i64x2_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { + self.check_simd_enabled(offset)?; + self.check_simd_lane_index(offset, lane, 2)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::I64)?; + Ok(()) + } + fn visit_i64x2_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { + self.check_simd_enabled(offset)?; + self.check_simd_lane_index(offset, lane, 2)?; + self.pop_operand(offset, Some(ValType::I64))?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_f32x4_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { + self.check_non_deterministic_enabled(offset)?; + self.check_simd_enabled(offset)?; + self.check_simd_lane_index(offset, lane, 4)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::F32)?; + Ok(()) + } + fn visit_f32x4_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { + self.check_non_deterministic_enabled(offset)?; + self.check_simd_enabled(offset)?; + self.check_simd_lane_index(offset, lane, 4)?; + self.pop_operand(offset, Some(ValType::F32))?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_f64x2_extract_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { + self.check_non_deterministic_enabled(offset)?; + self.check_simd_enabled(offset)?; + self.check_simd_lane_index(offset, lane, 2)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::F64)?; + Ok(()) + } + fn visit_f64x2_replace_lane(&mut self, offset: usize, lane: SIMDLaneIndex) -> Self::Output { + self.check_non_deterministic_enabled(offset)?; + self.check_simd_enabled(offset)?; + self.check_simd_lane_index(offset, lane, 2)?; + self.pop_operand(offset, Some(ValType::F64))?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_f32x4_eq(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f32x4_ne(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f32x4_lt(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f32x4_gt(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f32x4_le(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f32x4_ge(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f64x2_eq(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f64x2_ne(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f64x2_lt(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f64x2_gt(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f64x2_le(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f64x2_ge(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f32x4_add(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f32x4_sub(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f32x4_mul(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f32x4_div(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f32x4_min(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f32x4_max(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f32x4_p_min(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f32x4_p_max(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f64x2_add(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f64x2_sub(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f64x2_mul(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f64x2_div(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f64x2_min(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f64x2_max(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f64x2_p_min(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f64x2_p_max(&mut self, offset: usize) -> Self::Output { + self.check_v128_fbinary_op(offset) + } + fn visit_f32x4_relaxed_min(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_binary_op(offset) + } + fn visit_f32x4_relaxed_max(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_binary_op(offset) + } + fn visit_f64x2_relaxed_min(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_binary_op(offset) + } + fn visit_f64x2_relaxed_max(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_binary_op(offset) + } + fn visit_i8x16_eq(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_ne(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_lt_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_lt_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_gt_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_gt_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_le_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_le_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_ge_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_ge_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_eq(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_ne(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_lt_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_lt_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_gt_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_gt_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_le_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_le_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_ge_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_ge_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_eq(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_ne(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_lt_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_lt_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_gt_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_gt_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_le_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_le_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_ge_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_ge_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i64x2_eq(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i64x2_ne(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i64x2_lt_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i64x2_gt_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i64x2_le_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i64x2_ge_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_v128_and(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_v128_and_not(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_v128_or(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_v128_xor(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_add(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_add_sat_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_add_sat_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_sub(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_sub_sat_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_sub_sat_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_min_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_min_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_max_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_max_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_add(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_add_sat_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_add_sat_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_sub(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_sub_sat_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_sub_sat_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_mul(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_min_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_min_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_max_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_max_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_add(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_sub(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_mul(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_min_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_min_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_max_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_max_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_dot_i16x8_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i64x2_add(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i64x2_sub(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i64x2_mul(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_rounding_average_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_rounding_average_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_narrow_i16x8_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i8x16_narrow_i16x8_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_narrow_i32x4_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_narrow_i32x4_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_ext_mul_low_i8x16_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_ext_mul_high_i8x16_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_ext_mul_low_i8x16_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_ext_mul_high_i8x16_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_ext_mul_low_i16x8_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_ext_mul_high_i16x8_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_ext_mul_low_i16x8_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i32x4_ext_mul_high_i16x8_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i64x2_ext_mul_low_i32x4_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i64x2_ext_mul_high_i32x4_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i64x2_ext_mul_low_i32x4_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i64x2_ext_mul_high_i32x4_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_i16x8_q15_mulr_sat_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_binary_op(offset) + } + fn visit_f32x4_ceil(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f32x4_floor(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f32x4_trunc(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f32x4_nearest(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f64x2_ceil(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f64x2_floor(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f64x2_trunc(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f64x2_nearest(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f32x4_abs(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f32x4_neg(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f32x4_sqrt(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f64x2_abs(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f64x2_neg(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f64x2_sqrt(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f32x4_demote_f64x2_zero(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f64x2_promote_low_f32x4(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f64x2_convert_low_i32x4_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f64x2_convert_low_i32x4_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_i32x4_trunc_sat_f32x4_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_i32x4_trunc_sat_f32x4_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_i32x4_trunc_sat_f64x2_s_zero(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_i32x4_trunc_sat_f64x2_u_zero(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f32x4_convert_i32x4_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_f32x4_convert_i32x4_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_funary_op(offset) + } + fn visit_v128_not(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i8x16_abs(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i8x16_neg(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i8x16_popcnt(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i16x8_abs(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i16x8_neg(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i32x4_abs(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i32x4_neg(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i64x2_abs(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i64x2_neg(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i16x8_extend_low_i8x16_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i16x8_extend_high_i8x16_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i16x8_extend_low_i8x16_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i16x8_extend_high_i8x16_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i32x4_extend_low_i16x8_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i32x4_extend_high_i16x8_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i32x4_extend_low_i16x8_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i32x4_extend_high_i16x8_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i64x2_extend_low_i32x4_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i64x2_extend_high_i32x4_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i64x2_extend_low_i32x4_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i64x2_extend_high_i32x4_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i16x8_ext_add_pairwise_i8x16_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i16x8_ext_add_pairwise_i8x16_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i32x4_ext_add_pairwise_i16x8_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i32x4_ext_add_pairwise_i16x8_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_unary_op(offset) + } + fn visit_i32x4_relaxed_trunc_sat_f32x4_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_unary_op(offset) + } + fn visit_i32x4_relaxed_trunc_sat_f32x4_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_unary_op(offset) + } + fn visit_i32x4_relaxed_trunc_sat_f64x2_s_zero(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_unary_op(offset) + } + fn visit_i32x4_relaxed_trunc_sat_f64x2_u_zero(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_unary_op(offset) + } + fn visit_v128_bitselect(&mut self, offset: usize) -> Self::Output { + self.check_simd_enabled(offset)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_f32x4_fma(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_ternary_op(offset) + } + fn visit_f32x4_fms(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_ternary_op(offset) + } + fn visit_f64x2_fma(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_ternary_op(offset) + } + fn visit_f64x2_fms(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_ternary_op(offset) + } + fn visit_i8x16_lane_select(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_ternary_op(offset) + } + fn visit_i16x8_lane_select(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_ternary_op(offset) + } + fn visit_i32x4_lane_select(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_ternary_op(offset) + } + fn visit_i64x2_lane_select(&mut self, offset: usize) -> Self::Output { + self.check_v128_relaxed_ternary_op(offset) + } + fn visit_v128_any_true(&mut self, offset: usize) -> Self::Output { + self.check_v128_bitmask_op(offset) + } + fn visit_i8x16_all_true(&mut self, offset: usize) -> Self::Output { + self.check_v128_bitmask_op(offset) + } + fn visit_i8x16_bitmask(&mut self, offset: usize) -> Self::Output { + self.check_v128_bitmask_op(offset) + } + fn visit_i16x8_all_true(&mut self, offset: usize) -> Self::Output { + self.check_v128_bitmask_op(offset) + } + fn visit_i16x8_bitmask(&mut self, offset: usize) -> Self::Output { + self.check_v128_bitmask_op(offset) + } + fn visit_i32x4_all_true(&mut self, offset: usize) -> Self::Output { + self.check_v128_bitmask_op(offset) + } + fn visit_i32x4_bitmask(&mut self, offset: usize) -> Self::Output { + self.check_v128_bitmask_op(offset) + } + fn visit_i64x2_all_true(&mut self, offset: usize) -> Self::Output { + self.check_v128_bitmask_op(offset) + } + fn visit_i64x2_bitmask(&mut self, offset: usize) -> Self::Output { + self.check_v128_bitmask_op(offset) + } + fn visit_i8x16_shl(&mut self, offset: usize) -> Self::Output { + self.check_v128_shift_op(offset) + } + fn visit_i8x16_shr_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_shift_op(offset) + } + fn visit_i8x16_shr_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_shift_op(offset) + } + fn visit_i16x8_shl(&mut self, offset: usize) -> Self::Output { + self.check_v128_shift_op(offset) + } + fn visit_i16x8_shr_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_shift_op(offset) + } + fn visit_i16x8_shr_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_shift_op(offset) + } + fn visit_i32x4_shl(&mut self, offset: usize) -> Self::Output { + self.check_v128_shift_op(offset) + } + fn visit_i32x4_shr_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_shift_op(offset) + } + fn visit_i32x4_shr_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_shift_op(offset) + } + fn visit_i64x2_shl(&mut self, offset: usize) -> Self::Output { + self.check_v128_shift_op(offset) + } + fn visit_i64x2_shr_s(&mut self, offset: usize) -> Self::Output { + self.check_v128_shift_op(offset) + } + fn visit_i64x2_shr_u(&mut self, offset: usize) -> Self::Output { + self.check_v128_shift_op(offset) + } + fn visit_i8x16_swizzle(&mut self, offset: usize) -> Self::Output { + self.check_simd_enabled(offset)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_i8x16_relaxed_swizzle(&mut self, offset: usize) -> Self::Output { + self.check_relaxed_simd_enabled(offset)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(ValType::V128))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_i8x16_shuffle(&mut self, offset: usize, lanes: [SIMDLaneIndex; 16]) -> Self::Output { + self.check_simd_enabled(offset)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(ValType::V128))?; + for i in lanes { + self.check_simd_lane_index(offset, i, 32)?; + } + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_v128_load8_splat(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_simd_enabled(offset)?; + let ty = self.check_memarg(memarg, 0, offset)?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_v128_load16_splat(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_simd_enabled(offset)?; + let ty = self.check_memarg(memarg, 1, offset)?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_v128_load32_splat(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_simd_enabled(offset)?; + let ty = self.check_memarg(memarg, 2, offset)?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_v128_load32_zero(&mut self, input: usize, memarg: MemoryImmediate) -> Self::Output { + self.visit_v128_load32_splat(input, memarg) + } + fn visit_v128_load64_splat(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_v128_load_op(offset, memarg) + } + fn visit_v128_load64_zero(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_v128_load_op(offset, memarg) + } + fn visit_v128_load8x8_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_v128_load_op(offset, memarg) + } + fn visit_v128_load8x8_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_v128_load_op(offset, memarg) + } + fn visit_v128_load16x4_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_v128_load_op(offset, memarg) + } + fn visit_v128_load16x4_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_v128_load_op(offset, memarg) + } + fn visit_v128_load32x2_s(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_v128_load_op(offset, memarg) + } + fn visit_v128_load32x2_u(&mut self, offset: usize, memarg: MemoryImmediate) -> Self::Output { + self.check_v128_load_op(offset, memarg) + } + fn visit_v128_load8_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output { + self.check_simd_enabled(offset)?; + let idx = self.check_memarg(memarg, 0, offset)?; + self.check_simd_lane_index(offset, lane, 16)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(idx))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_v128_load16_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output { + self.check_simd_enabled(offset)?; + let idx = self.check_memarg(memarg, 1, offset)?; + self.check_simd_lane_index(offset, lane, 8)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(idx))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_v128_load32_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output { + self.check_simd_enabled(offset)?; + let idx = self.check_memarg(memarg, 2, offset)?; + self.check_simd_lane_index(offset, lane, 4)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(idx))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_v128_load64_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output { + self.check_simd_enabled(offset)?; + let idx = self.check_memarg(memarg, 3, offset)?; + self.check_simd_lane_index(offset, lane, 2)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(idx))?; + self.push_operand(ValType::V128)?; + Ok(()) + } + fn visit_v128_store8_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output { + self.check_simd_enabled(offset)?; + let idx = self.check_memarg(memarg, 0, offset)?; + self.check_simd_lane_index(offset, lane, 16)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(idx))?; + Ok(()) + } + fn visit_v128_store16_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output { + self.check_simd_enabled(offset)?; + let idx = self.check_memarg(memarg, 1, offset)?; + self.check_simd_lane_index(offset, lane, 8)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(idx))?; + Ok(()) + } + fn visit_v128_store32_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output { + self.check_simd_enabled(offset)?; + let idx = self.check_memarg(memarg, 2, offset)?; + self.check_simd_lane_index(offset, lane, 4)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(idx))?; + Ok(()) + } + fn visit_v128_store64_lane( + &mut self, + offset: usize, + memarg: MemoryImmediate, + lane: SIMDLaneIndex, + ) -> Self::Output { + self.check_simd_enabled(offset)?; + let idx = self.check_memarg(memarg, 3, offset)?; + self.check_simd_lane_index(offset, lane, 2)?; + self.pop_operand(offset, Some(ValType::V128))?; + self.pop_operand(offset, Some(idx))?; + Ok(()) + } + fn visit_memory_init(&mut self, offset: usize, segment: u32, mem: u32) -> Self::Output { + self.check_bulk_memory_enabled(offset)?; + let ty = self.check_memory_index(offset, mem)?; + match self.resources.data_count() { + None => bail_op_err!(offset, "data count section required"), + Some(count) if segment < count => {} + Some(_) => bail_op_err!(offset, "unknown data segment {}", segment), + } + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ty))?; + Ok(()) + } + fn visit_data_drop(&mut self, offset: usize, segment: u32) -> Self::Output { + self.check_bulk_memory_enabled(offset)?; + match self.resources.data_count() { + None => bail_op_err!(offset, "data count section required"), + Some(count) if segment < count => {} + Some(_) => bail_op_err!(offset, "unknown data segment {}", segment), + } + Ok(()) + } + fn visit_memory_copy(&mut self, offset: usize, dst: u32, src: u32) -> Self::Output { + self.check_bulk_memory_enabled(offset)?; + let dst_ty = self.check_memory_index(offset, dst)?; + let src_ty = self.check_memory_index(offset, src)?; + + // The length operand here is the smaller of src/dst, which is + // i32 if one is i32 + self.pop_operand( + offset, + Some(match src_ty { + ValType::I32 => ValType::I32, + _ => dst_ty, + }), + )?; + + // ... and the offset into each memory is required to be + // whatever the indexing type is for that memory + self.pop_operand(offset, Some(src_ty))?; + self.pop_operand(offset, Some(dst_ty))?; + Ok(()) + } + fn visit_memory_fill(&mut self, offset: usize, mem: u32) -> Self::Output { + self.check_bulk_memory_enabled(offset)?; + let ty = self.check_memory_index(offset, mem)?; + self.pop_operand(offset, Some(ty))?; + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ty))?; + Ok(()) + } + fn visit_table_init(&mut self, offset: usize, segment: u32, table: u32) -> Self::Output { + self.check_bulk_memory_enabled(offset)?; + if table > 0 { + self.check_reference_types_enabled(offset)?; + } + let table = match self.resources.table_at(table) { + Some(table) => table, + None => bail_op_err!(offset, "unknown table {}: table index out of bounds", table), + }; + let segment_ty = match self.resources.element_type_at(segment) { + Some(ty) => ty, + None => bail_op_err!( + offset, + "unknown elem segment {}: segment index out of bounds", + segment + ), + }; + if segment_ty != table.element_type { + bail_op_err!(offset, "type mismatch"); + } + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ValType::I32))?; + Ok(()) + } + fn visit_elem_drop(&mut self, offset: usize, segment: u32) -> Self::Output { + self.check_bulk_memory_enabled(offset)?; + if segment >= self.resources.element_count() { + bail_op_err!( + offset, + "unknown elem segment {}: segment index out of bounds", + segment + ); + } + Ok(()) + } + fn visit_table_copy(&mut self, offset: usize, dst_table: u32, src_table: u32) -> Self::Output { + self.check_bulk_memory_enabled(offset)?; + if src_table > 0 || dst_table > 0 { + self.check_reference_types_enabled(offset)?; + } + let (src, dst) = match ( + self.resources.table_at(src_table), + self.resources.table_at(dst_table), + ) { + (Some(a), Some(b)) => (a, b), + _ => bail_op_err!(offset, "table index out of bounds"), + }; + if src.element_type != dst.element_type { + bail_op_err!(offset, "type mismatch"); + } + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ValType::I32))?; + Ok(()) + } + fn visit_table_get(&mut self, offset: usize, table: u32) -> Self::Output { + self.check_reference_types_enabled(offset)?; + let ty = match self.resources.table_at(table) { + Some(ty) => ty.element_type, + None => bail_op_err!(offset, "table index out of bounds"), + }; + self.pop_operand(offset, Some(ValType::I32))?; + self.push_operand(ty)?; + Ok(()) + } + fn visit_table_set(&mut self, offset: usize, table: u32) -> Self::Output { + self.check_reference_types_enabled(offset)?; + let ty = match self.resources.table_at(table) { + Some(ty) => ty.element_type, + None => bail_op_err!(offset, "table index out of bounds"), + }; + self.pop_operand(offset, Some(ty))?; + self.pop_operand(offset, Some(ValType::I32))?; + Ok(()) + } + fn visit_table_grow(&mut self, offset: usize, table: u32) -> Self::Output { + self.check_reference_types_enabled(offset)?; + let ty = match self.resources.table_at(table) { + Some(ty) => ty.element_type, + None => bail_op_err!(offset, "table index out of bounds"), + }; + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ty))?; + self.push_operand(ValType::I32)?; + Ok(()) + } + fn visit_table_size(&mut self, offset: usize, table: u32) -> Self::Output { + self.check_reference_types_enabled(offset)?; + if self.resources.table_at(table).is_none() { + bail_op_err!(offset, "table index out of bounds"); + } + self.push_operand(ValType::I32)?; + Ok(()) + } + fn visit_table_fill(&mut self, offset: usize, table: u32) -> Self::Output { + self.check_bulk_memory_enabled(offset)?; + let ty = match self.resources.table_at(table) { + Some(ty) => ty.element_type, + None => bail_op_err!(offset, "table index out of bounds"), + }; + self.pop_operand(offset, Some(ValType::I32))?; + self.pop_operand(offset, Some(ty))?; + self.pop_operand(offset, Some(ValType::I32))?; + Ok(()) + } + + fn visit_memory_read_pkru(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } + fn visit_memory_write_pkru(&mut self, offset: usize) -> Self::Output { + self.check_binary_op(offset, ValType::I32) + } +} + +enum Either { + A(A), + B(B), +} + +impl Iterator for Either +where + A: Iterator, + B: Iterator, +{ + type Item = A::Item; + fn next(&mut self) -> Option { + match self { + Either::A(a) => a.next(), + Either::B(b) => b.next(), + } + } +} + +impl DoubleEndedIterator for Either +where + A: DoubleEndedIterator, + B: DoubleEndedIterator, +{ + fn next_back(&mut self) -> Option { + match self { + Either::A(a) => a.next_back(), + Either::B(b) => b.next_back(), + } + } +} + +impl ExactSizeIterator for Either +where + A: ExactSizeIterator, + B: ExactSizeIterator, +{ + fn len(&self) -> usize { + match self { + Either::A(a) => a.len(), + Either::B(b) => b.len(), + } + } +} + +trait PreciseIterator: ExactSizeIterator + DoubleEndedIterator {} +impl PreciseIterator for T {} diff --git a/crates/wasmparser/src/validator/types.rs b/crates/wasmparser/src/validator/types.rs new file mode 100644 index 000000000..3b60b5d19 --- /dev/null +++ b/crates/wasmparser/src/validator/types.rs @@ -0,0 +1,1901 @@ +//! Types relating to type information provided by validation. + +use super::{component::ComponentState, core::Module}; +use crate::{ + ComponentExport, ComponentExternalKind, ComponentImport, ComponentTypeRef, Export, + ExternalKind, FuncType, GlobalType, Import, MemoryType, PrimitiveValType, TableType, TypeRef, + ValType, +}; +use indexmap::{IndexMap, IndexSet}; +use std::{ + borrow::Borrow, + hash::{Hash, Hasher}, + mem, + sync::Arc, +}; + +/// The maximum number of parameters in the canonical ABI that can be passed by value. +/// +/// Functions that exceed this limit will instead pass parameters indirectly from +/// linear memory via a single pointer parameter. +const MAX_FLAT_FUNC_PARAMS: usize = 16; +/// The maximum number of results in the canonical ABI that can be returned by a function. +/// +/// Functions that exceed this limit have their results written to linear memory via an +/// additional pointer parameter (imports) or return a single pointer value (exports). +const MAX_FLAT_FUNC_RESULTS: usize = 1; + +/// The maximum lowered types, including a possible type for a return pointer parameter. +const MAX_LOWERED_TYPES: usize = MAX_FLAT_FUNC_PARAMS + 1; + +/// A simple alloc-free list of types used for calculating lowered function signatures. +pub(crate) struct LoweredTypes { + types: [ValType; MAX_LOWERED_TYPES], + len: usize, + max: usize, +} + +impl LoweredTypes { + fn new(max: usize) -> Self { + assert!(max <= MAX_LOWERED_TYPES); + Self { + types: [ValType::I32; MAX_LOWERED_TYPES], + len: 0, + max, + } + } + + fn len(&self) -> usize { + self.len + } + + fn maxed(&self) -> bool { + self.len == self.max + } + + fn get_mut(&mut self, index: usize) -> Option<&mut ValType> { + if index < self.len { + Some(&mut self.types[index]) + } else { + None + } + } + + fn push(&mut self, ty: ValType) -> bool { + if self.maxed() { + return false; + } + + self.types[self.len] = ty; + self.len += 1; + true + } + + fn clear(&mut self) { + self.len = 0; + } + + pub fn as_slice(&self) -> &[ValType] { + &self.types[..self.len] + } + + pub fn iter(&self) -> impl Iterator + '_ { + self.as_slice().iter().copied() + } +} + +/// Represents information about a component function type lowering. +pub(crate) struct LoweringInfo { + pub(crate) params: LoweredTypes, + pub(crate) results: LoweredTypes, + pub(crate) requires_memory: bool, + pub(crate) requires_realloc: bool, +} + +impl LoweringInfo { + pub(crate) fn into_func_type(self) -> FuncType { + FuncType { + params: self.params.as_slice().to_vec().into_boxed_slice(), + returns: self.results.as_slice().to_vec().into_boxed_slice(), + } + } +} + +impl Default for LoweringInfo { + fn default() -> Self { + Self { + params: LoweredTypes::new(MAX_FLAT_FUNC_PARAMS), + results: LoweredTypes::new(MAX_FLAT_FUNC_RESULTS), + requires_memory: false, + requires_realloc: false, + } + } +} + +fn push_primitive_wasm_types(ty: &PrimitiveValType, lowered_types: &mut LoweredTypes) -> bool { + match ty { + PrimitiveValType::Bool + | PrimitiveValType::S8 + | PrimitiveValType::U8 + | PrimitiveValType::S16 + | PrimitiveValType::U16 + | PrimitiveValType::S32 + | PrimitiveValType::U32 + | PrimitiveValType::Char => lowered_types.push(ValType::I32), + PrimitiveValType::S64 | PrimitiveValType::U64 => lowered_types.push(ValType::I64), + PrimitiveValType::Float32 => lowered_types.push(ValType::F32), + PrimitiveValType::Float64 => lowered_types.push(ValType::F64), + PrimitiveValType::String => { + lowered_types.push(ValType::I32) && lowered_types.push(ValType::I32) + } + } +} + +/// Represents a unique identifier for a type known to a [`crate::Validator`]. +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub struct TypeId { + /// The effective type size for the type. + /// + /// This is stored as part of the ID to avoid having to recurse through + /// the global type list when calculating type sizes. + pub(crate) type_size: usize, + /// The index into the global list of types. + pub(crate) index: usize, +} + +/// A unified type definition for validating WebAssembly modules and components. +#[derive(Debug)] +pub enum Type { + /// The definition is for a core function type. + Func(FuncType), + /// The definition is for a core module type. + /// + /// This variant is only supported when parsing a component. + Module(ModuleType), + /// The definition is for a core module instance type. + /// + /// This variant is only supported when parsing a component. + Instance(InstanceType), + /// The definition is for a component type. + /// + /// This variant is only supported when parsing a component. + Component(ComponentType), + /// The definition is for a component instance type. + /// + /// This variant is only supported when parsing a component. + ComponentInstance(ComponentInstanceType), + /// The definition is for a component function type. + /// + /// This variant is only supported when parsing a component. + ComponentFunc(ComponentFuncType), + /// The definition is for a component defined type. + /// + /// This variant is only supported when parsing a component. + Defined(ComponentDefinedType), +} + +impl Type { + /// Converts the type to a core function type. + pub fn as_func_type(&self) -> Option<&FuncType> { + match self { + Self::Func(ty) => Some(ty), + _ => None, + } + } + + /// Converts the type to a core module type. + pub fn as_module_type(&self) -> Option<&ModuleType> { + match self { + Self::Module(ty) => Some(ty), + _ => None, + } + } + + /// Converts the type to a core module instance type. + pub fn as_instance_type(&self) -> Option<&InstanceType> { + match self { + Self::Instance(ty) => Some(ty), + _ => None, + } + } + + /// Converts the type to a component type. + pub fn as_component_type(&self) -> Option<&ComponentType> { + match self { + Self::Component(ty) => Some(ty), + _ => None, + } + } + + /// Converts the type to a component instance type. + pub fn as_component_instance_type(&self) -> Option<&ComponentInstanceType> { + match self { + Self::ComponentInstance(ty) => Some(ty), + _ => None, + } + } + + /// Converts the type to a component function type. + pub fn as_component_func_type(&self) -> Option<&ComponentFuncType> { + match self { + Self::ComponentFunc(ty) => Some(ty), + _ => None, + } + } + + /// Converts the type to a component defined type. + pub fn as_defined_type(&self) -> Option<&ComponentDefinedType> { + match self { + Self::Defined(ty) => Some(ty), + _ => None, + } + } + + pub(crate) fn type_size(&self) -> usize { + match self { + Self::Func(ty) => 1 + ty.params.len() + ty.returns.len(), + Self::Module(ty) => ty.type_size, + Self::Instance(ty) => ty.type_size, + Self::Component(ty) => ty.type_size, + Self::ComponentInstance(ty) => ty.type_size, + Self::ComponentFunc(ty) => ty.type_size, + Self::Defined(ty) => ty.type_size(), + } + } +} + +/// A component value type. +#[derive(Debug, Clone, Copy)] +pub enum ComponentValType { + /// The value type is one of the primitive types. + Primitive(PrimitiveValType), + /// The type is represented with the given type identifier. + Type(TypeId), +} + +impl ComponentValType { + pub(crate) fn requires_realloc(&self, types: &TypeList) -> bool { + match self { + ComponentValType::Primitive(ty) => ty.requires_realloc(), + ComponentValType::Type(ty) => types[*ty] + .as_defined_type() + .unwrap() + .requires_realloc(types), + } + } + + pub(crate) fn is_optional(&self, types: &TypeList) -> bool { + match self { + ComponentValType::Primitive(_) => false, + ComponentValType::Type(ty) => { + matches!( + types[*ty].as_defined_type().unwrap(), + ComponentDefinedType::Option(_) + ) + } + } + } + + /// Determines if component value type `a` is a subtype of `b`. + pub fn is_subtype_of(a: &Self, at: TypesRef, b: &Self, bt: TypesRef) -> bool { + Self::internal_is_subtype_of(a, at.list, b, bt.list) + } + + pub(crate) fn internal_is_subtype_of(a: &Self, at: &TypeList, b: &Self, bt: &TypeList) -> bool { + match (a, b) { + (ComponentValType::Primitive(a), ComponentValType::Primitive(b)) => { + PrimitiveValType::is_subtype_of(*a, *b) + } + (ComponentValType::Type(a), ComponentValType::Type(b)) => { + ComponentDefinedType::internal_is_subtype_of( + at[*a].as_defined_type().unwrap(), + at, + bt[*b].as_defined_type().unwrap(), + bt, + ) + } + (ComponentValType::Primitive(a), ComponentValType::Type(b)) => { + match bt[*b].as_defined_type().unwrap() { + ComponentDefinedType::Primitive(b) => PrimitiveValType::is_subtype_of(*a, *b), + _ => false, + } + } + (ComponentValType::Type(a), ComponentValType::Primitive(b)) => { + match at[*a].as_defined_type().unwrap() { + ComponentDefinedType::Primitive(a) => PrimitiveValType::is_subtype_of(*a, *b), + _ => false, + } + } + } + } + + fn push_wasm_types(&self, types: &TypeList, lowered_types: &mut LoweredTypes) -> bool { + match self { + Self::Primitive(ty) => push_primitive_wasm_types(ty, lowered_types), + Self::Type(id) => types[*id] + .as_defined_type() + .unwrap() + .push_wasm_types(types, lowered_types), + } + } + + pub(crate) fn type_size(&self) -> usize { + match self { + Self::Primitive(_) => 1, + Self::Type(id) => id.type_size, + } + } +} + +/// The entity type for imports and exports of a module. +#[derive(Debug, Clone, Copy)] +pub enum EntityType { + /// The entity is a function. + Func(TypeId), + /// The entity is a table. + Table(TableType), + /// The entity is a memory. + Memory(MemoryType), + /// The entity is a global. + Global(GlobalType), + /// The entity is a tag. + Tag(TypeId), +} + +impl EntityType { + /// Determines if entity type `a` is a subtype of `b`. + pub fn is_subtype_of(a: &Self, at: TypesRef, b: &Self, bt: TypesRef) -> bool { + Self::internal_is_subtype_of(a, at.list, b, bt.list) + } + + pub(crate) fn internal_is_subtype_of(a: &Self, at: &TypeList, b: &Self, bt: &TypeList) -> bool { + macro_rules! limits_match { + ($a:expr, $b:expr) => {{ + let a = $a; + let b = $b; + a.initial >= b.initial + && match b.maximum { + Some(b_max) => match a.maximum { + Some(a_max) => a_max <= b_max, + None => false, + }, + None => true, + } + }}; + } + + match (a, b) { + (EntityType::Func(a), EntityType::Func(b)) => { + at[*a].as_func_type().unwrap() == bt[*b].as_func_type().unwrap() + } + (EntityType::Table(a), EntityType::Table(b)) => { + a.element_type == b.element_type && limits_match!(a, b) + } + (EntityType::Memory(a), EntityType::Memory(b)) => { + a.shared == b.shared && a.memory64 == b.memory64 && limits_match!(a, b) + } + (EntityType::Global(a), EntityType::Global(b)) => a == b, + (EntityType::Tag(a), EntityType::Tag(b)) => { + at[*a].as_func_type().unwrap() == bt[*b].as_func_type().unwrap() + } + _ => false, + } + } + + pub(crate) fn desc(&self) -> &'static str { + match self { + Self::Func(_) => "function", + Self::Table(_) => "table", + Self::Memory(_) => "memory", + Self::Global(_) => "global", + Self::Tag(_) => "tag", + } + } + + pub(crate) fn type_size(&self) -> usize { + match self { + Self::Func(id) | Self::Tag(id) => id.type_size, + Self::Table(_) | Self::Memory(_) | Self::Global(_) => 1, + } + } +} + +trait ModuleImportKey { + fn module(&self) -> &str; + fn name(&self) -> &str; +} + +impl<'a> Borrow for (String, String) { + fn borrow(&self) -> &(dyn ModuleImportKey + 'a) { + self + } +} + +impl Hash for (dyn ModuleImportKey + '_) { + fn hash(&self, state: &mut H) { + self.module().hash(state); + self.name().hash(state); + } +} + +impl PartialEq for (dyn ModuleImportKey + '_) { + fn eq(&self, other: &Self) -> bool { + self.module() == other.module() && self.name() == other.name() + } +} + +impl Eq for (dyn ModuleImportKey + '_) {} + +impl ModuleImportKey for (String, String) { + fn module(&self) -> &str { + &self.0 + } + + fn name(&self) -> &str { + &self.1 + } +} + +impl ModuleImportKey for (&str, &str) { + fn module(&self) -> &str { + self.0 + } + + fn name(&self) -> &str { + self.1 + } +} + +/// Represents a core module type. +#[derive(Debug, Clone)] +pub struct ModuleType { + /// The effective type size for the module type. + pub(crate) type_size: usize, + /// The imports of the module type. + pub imports: IndexMap<(String, String), EntityType>, + /// The exports of the module type. + pub exports: IndexMap, +} + +impl ModuleType { + /// Looks up an import by its module and name. + /// + /// Returns `None` if the import was not found. + pub fn lookup_import(&self, module: &str, name: &str) -> Option<&EntityType> { + self.imports.get(&(module, name) as &dyn ModuleImportKey) + } + + /// Determines if module type `a` is a subtype of `b`. + pub fn is_subtype_of(a: &Self, at: TypesRef, b: &Self, bt: TypesRef) -> bool { + Self::internal_is_subtype_of(a, at.list, b, bt.list) + } + + pub(crate) fn internal_is_subtype_of(a: &Self, at: &TypeList, b: &Self, bt: &TypeList) -> bool { + // For module type subtyping, all exports in the other module type + // must be present in this module type's exports (i.e. it can export + // *more* than what this module type needs). + // However, for imports, the check is reversed (i.e. it is okay + // to import *less* than what this module type needs). + a.imports.iter().all(|(k, a)| match b.imports.get(k) { + Some(b) => EntityType::internal_is_subtype_of(b, bt, a, at), + None => false, + }) && b.exports.iter().all(|(k, b)| match a.exports.get(k) { + Some(a) => EntityType::internal_is_subtype_of(a, at, b, bt), + None => false, + }) + } +} + +/// Represents the kind of module instance type. +#[derive(Debug, Clone)] +pub enum InstanceTypeKind { + /// The instance type is the result of instantiating a module type. + Instantiated(TypeId), + /// The instance type is the result of instantiating from exported items. + Exports(IndexMap), +} + +/// Represents a module instance type. +#[derive(Debug, Clone)] +pub struct InstanceType { + /// The effective type size for the module instance type. + pub(crate) type_size: usize, + /// The kind of module instance type. + pub kind: InstanceTypeKind, +} + +impl InstanceType { + /// Gets the exports of the instance type. + pub fn exports<'a>(&'a self, types: TypesRef<'a>) -> &'a IndexMap { + self.internal_exports(types.list) + } + + pub(crate) fn internal_exports<'a>( + &'a self, + types: &'a TypeList, + ) -> &'a IndexMap { + match &self.kind { + InstanceTypeKind::Instantiated(id) => &types[*id].as_module_type().unwrap().exports, + InstanceTypeKind::Exports(exports) => exports, + } + } +} + +/// The entity type for imports and exports of a component. +#[derive(Debug, Clone, Copy)] +pub enum ComponentEntityType { + /// The entity is a core module. + Module(TypeId), + /// The entity is a function. + Func(TypeId), + /// The entity is a value. + Value(ComponentValType), + /// The entity is a type. + Type(TypeId), + /// The entity is a component instance. + Instance(TypeId), + /// The entity is a component. + Component(TypeId), +} + +impl ComponentEntityType { + /// Determines if component entity type `a` is a subtype of `b`. + pub fn is_subtype_of(a: &Self, at: TypesRef, b: &Self, bt: TypesRef) -> bool { + Self::internal_is_subtype_of(a, at.list, b, bt.list) + } + + pub(crate) fn internal_is_subtype_of(a: &Self, at: &TypeList, b: &Self, bt: &TypeList) -> bool { + match (a, b) { + (Self::Module(a), Self::Module(b)) => ModuleType::internal_is_subtype_of( + at[*a].as_module_type().unwrap(), + at, + bt[*b].as_module_type().unwrap(), + bt, + ), + (Self::Func(a), Self::Func(b)) => ComponentFuncType::internal_is_subtype_of( + at[*a].as_component_func_type().unwrap(), + at, + bt[*b].as_component_func_type().unwrap(), + bt, + ), + (Self::Value(a), Self::Value(b)) => { + ComponentValType::internal_is_subtype_of(a, at, b, bt) + } + (Self::Type(a), Self::Type(b)) => ComponentDefinedType::internal_is_subtype_of( + at[*a].as_defined_type().unwrap(), + at, + bt[*b].as_defined_type().unwrap(), + bt, + ), + (Self::Instance(a), Self::Instance(b)) => { + ComponentInstanceType::internal_is_subtype_of( + at[*a].as_component_instance_type().unwrap(), + at, + bt[*b].as_component_instance_type().unwrap(), + bt, + ) + } + (Self::Component(a), Self::Component(b)) => ComponentType::internal_is_subtype_of( + at[*a].as_component_type().unwrap(), + at, + bt[*b].as_component_type().unwrap(), + bt, + ), + _ => false, + } + } + + pub(crate) fn desc(&self) -> &'static str { + match self { + Self::Module(_) => "module", + Self::Func(_) => "function", + Self::Value(_) => "value", + Self::Type(_) => "type", + Self::Instance(_) => "instance", + Self::Component(_) => "component", + } + } + + pub(crate) fn type_size(&self) -> usize { + match self { + Self::Module(ty) + | Self::Func(ty) + | Self::Type(ty) + | Self::Instance(ty) + | Self::Component(ty) => ty.type_size, + Self::Value(ty) => ty.type_size(), + } + } +} + +/// Represents a type of a component. +#[derive(Debug, Clone)] +pub struct ComponentType { + /// The effective type size for the component type. + pub(crate) type_size: usize, + /// The imports of the component type. + pub imports: IndexMap, + /// The exports of the component type. + pub exports: IndexMap, +} + +impl ComponentType { + /// Determines if component type `a` is a subtype of `b`. + pub fn is_subtype_of(a: &Self, at: TypesRef, b: &Self, bt: TypesRef) -> bool { + Self::internal_is_subtype_of(a, at.list, b, bt.list) + } + + pub(crate) fn internal_is_subtype_of(a: &Self, at: &TypeList, b: &Self, bt: &TypeList) -> bool { + // For component type subtyping, all exports in the other component type + // must be present in this component type's exports (i.e. it can export + // *more* than what this component type needs). + // However, for imports, the check is reversed (i.e. it is okay + // to import *less* than what this component type needs). + a.imports.iter().all(|(k, a)| match b.imports.get(k) { + Some(b) => ComponentEntityType::internal_is_subtype_of(b, bt, a, at), + None => false, + }) && b.exports.iter().all(|(k, b)| match a.exports.get(k) { + Some(a) => ComponentEntityType::internal_is_subtype_of(a, at, b, bt), + None => false, + }) + } +} + +/// Represents the kind of a component instance. +#[derive(Debug, Clone)] +pub enum ComponentInstanceTypeKind { + /// The instance type is from a definition. + Defined(IndexMap), + /// The instance type is the result of instantiating a component type. + Instantiated(TypeId), + /// The instance type is the result of instantiating from exported items. + Exports(IndexMap), +} + +/// Represents a type of a component instance. +#[derive(Debug, Clone)] +pub struct ComponentInstanceType { + /// The effective type size for the instance type. + pub(crate) type_size: usize, + /// The kind of instance type. + pub kind: ComponentInstanceTypeKind, +} + +impl ComponentInstanceType { + /// Gets the exports of the instance type. + pub fn exports<'a>(&'a self, types: TypesRef<'a>) -> &'a IndexMap { + self.internal_exports(types.list) + } + + pub(crate) fn internal_exports<'a>( + &'a self, + types: &'a TypeList, + ) -> &'a IndexMap { + match &self.kind { + ComponentInstanceTypeKind::Defined(exports) + | ComponentInstanceTypeKind::Exports(exports) => exports, + ComponentInstanceTypeKind::Instantiated(id) => { + &types[*id].as_component_type().unwrap().exports + } + } + } + + /// Determines if component instance type `a` is a subtype of `b`. + pub fn is_subtype_of(a: &Self, at: TypesRef, b: &Self, bt: TypesRef) -> bool { + Self::internal_is_subtype_of(a, at.list, b, bt.list) + } + + pub(crate) fn internal_is_subtype_of(a: &Self, at: &TypeList, b: &Self, bt: &TypeList) -> bool { + let exports = a.internal_exports(at); + + // For instance type subtyping, all exports in the other instance type + // must be present in this instance type's exports (i.e. it can export + // *more* than what this instance type needs). + b.internal_exports(bt) + .iter() + .all(|(k, b)| match exports.get(k) { + Some(a) => ComponentEntityType::internal_is_subtype_of(a, at, b, bt), + None => false, + }) + } +} + +/// Represents a type of a component function. +#[derive(Debug, Clone)] +pub struct ComponentFuncType { + /// The effective type size for the component function type. + pub(crate) type_size: usize, + /// The function parameters. + pub params: Box<[(Option, ComponentValType)]>, + /// The function's results. + pub results: Box<[(Option, ComponentValType)]>, +} + +impl ComponentFuncType { + /// Determines if component function type `a` is a subtype of `b`. + pub fn is_subtype_of(a: &Self, at: TypesRef, b: &Self, bt: TypesRef) -> bool { + Self::internal_is_subtype_of(a, at.list, b, bt.list) + } + + pub(crate) fn internal_is_subtype_of(a: &Self, at: &TypeList, b: &Self, bt: &TypeList) -> bool { + // Subtyping rules: + // https://github.com/WebAssembly/component-model/blob/main/design/mvp/Subtyping.md + + // The subtype cannot have more parameters than the supertype + if b.params.len() < a.params.len() { + return false; + } + + // The supertype cannot have more results than the subtype + if a.results.len() < b.results.len() { + return false; + } + + for ((an, a), (bn, b)) in a.params.iter().zip(b.params.iter()) { + // All overlapping parameters must have the same name + if an != bn { + return false; + } + + // Contravariant on parameters + if !ComponentValType::internal_is_subtype_of(b, bt, a, at) { + return false; + } + } + + // All remaining parameters in the supertype must be optional + if !b + .params + .iter() + .skip(a.params.len()) + .all(|(_, b)| b.is_optional(bt)) + { + return false; + } + + for ((an, a), (bn, b)) in a.results.iter().zip(b.results.iter()) { + // All overlapping results must have the same name + if an != bn { + return false; + } + + // Covariant on results + if !ComponentValType::internal_is_subtype_of(a, at, b, bt) { + return false; + } + } + + true + } + + /// Lowers the component function type to core parameter and result types for the + /// canonical ABI. + pub(crate) fn lower(&self, types: &TypeList, import: bool) -> LoweringInfo { + let mut info = LoweringInfo::default(); + + for (_, ty) in self.params.iter() { + // When `import` is false, it means we're lifting a core function, + // check if the parameters needs realloc + if !import && !info.requires_realloc { + info.requires_realloc = ty.requires_realloc(types); + } + + if !ty.push_wasm_types(types, &mut info.params) { + // Too many parameters to pass directly + // Function will have a single pointer parameter to pass the arguments + // via linear memory + info.params.clear(); + assert!(info.params.push(ValType::I32)); + info.requires_memory = true; + + // We need realloc as well when lifting a function + if !import { + info.requires_realloc = true; + } + break; + } + } + + for (_, ty) in self.results.iter() { + // When `import` is true, it means we're lowering a component function, + // check if the result needs realloc + if import && !info.requires_realloc { + info.requires_realloc = ty.requires_realloc(types); + } + + if !ty.push_wasm_types(types, &mut info.results) { + // Too many results to return directly, either a retptr parameter will be used (import) + // or a single pointer will be returned (export) + info.results.clear(); + if import { + info.params.max = MAX_LOWERED_TYPES; + assert!(info.params.push(ValType::I32)); + } else { + assert!(info.results.push(ValType::I32)); + } + info.requires_memory = true; + break; + } + } + + // Memory is always required when realloc is required + info.requires_memory |= info.requires_realloc; + + info + } +} + +/// Represents a variant case. +#[derive(Debug, Clone)] +pub struct VariantCase { + /// The variant case type. + pub ty: Option, + /// The name of the variant case refined by this one. + pub refines: Option, +} + +/// Represents a record type. +#[derive(Debug, Clone)] +pub struct RecordType { + /// The effective type size for the record type. + pub(crate) type_size: usize, + /// The map of record fields. + pub fields: IndexMap, +} + +/// Represents a variant type. +#[derive(Debug, Clone)] +pub struct VariantType { + /// The effective type size for the variant type. + pub(crate) type_size: usize, + /// The map of variant cases. + pub cases: IndexMap, +} + +/// Represents a tuple type. +#[derive(Debug, Clone)] +pub struct TupleType { + /// The effective type size for the tuple type. + pub(crate) type_size: usize, + /// The types of the tuple. + pub types: Box<[ComponentValType]>, +} + +/// Represents a union type. +#[derive(Debug, Clone)] +pub struct UnionType { + /// The inclusive type count for the union type. + pub(crate) type_size: usize, + /// The types of the union. + pub types: Box<[ComponentValType]>, +} + +/// Represents a component defined type. +#[derive(Debug, Clone)] +pub enum ComponentDefinedType { + /// The type is a primitive value type. + Primitive(PrimitiveValType), + /// The type is a record. + Record(RecordType), + /// The type is a variant. + Variant(VariantType), + /// The type is a list. + List(ComponentValType), + /// The type is a tuple. + Tuple(TupleType), + /// The type is a set of flags. + Flags(IndexSet), + /// The type is an enumeration. + Enum(IndexSet), + /// The type is a union. + Union(UnionType), + /// The type is an `option`. + Option(ComponentValType), + /// The type is a `result`. + Result { + /// The `ok` type. + ok: Option, + /// The `error` type. + err: Option, + }, +} + +impl ComponentDefinedType { + pub(crate) fn requires_realloc(&self, types: &TypeList) -> bool { + match self { + Self::Primitive(ty) => ty.requires_realloc(), + Self::Record(r) => r.fields.values().any(|ty| ty.requires_realloc(types)), + Self::Variant(v) => v.cases.values().any(|case| { + case.ty + .map(|ty| ty.requires_realloc(types)) + .unwrap_or(false) + }), + Self::List(_) => true, + Self::Tuple(t) => t.types.iter().any(|ty| ty.requires_realloc(types)), + Self::Union(u) => u.types.iter().any(|ty| ty.requires_realloc(types)), + Self::Flags(_) | Self::Enum(_) => false, + Self::Option(ty) => ty.requires_realloc(types), + Self::Result { ok, err } => { + ok.map(|ty| ty.requires_realloc(types)).unwrap_or(false) + || err.map(|ty| ty.requires_realloc(types)).unwrap_or(false) + } + } + } + + /// Determines if component defined type `a` is a subtype of `b`. + pub fn is_subtype_of(a: &Self, at: TypesRef, b: &Self, bt: TypesRef) -> bool { + Self::internal_is_subtype_of(a, at.list, b, bt.list) + } + + pub(crate) fn internal_is_subtype_of(a: &Self, at: &TypeList, b: &Self, bt: &TypeList) -> bool { + // Subtyping rules according to + // https://github.com/WebAssembly/component-model/blob/main/design/mvp/Subtyping.md + match (a, b) { + (Self::Primitive(a), Self::Primitive(b)) => PrimitiveValType::is_subtype_of(*a, *b), + (Self::Record(a), Self::Record(b)) => { + for (name, a) in a.fields.iter() { + if let Some(b) = b.fields.get(name) { + if !ComponentValType::internal_is_subtype_of(a, at, b, bt) { + return false; + } + } else { + // Superfluous fields can be ignored in the subtype + } + } + // Check for missing required fields in the supertype + for (name, b) in b.fields.iter() { + if !b.is_optional(bt) && !a.fields.contains_key(name) { + return false; + } + } + true + } + (Self::Variant(a), Self::Variant(b)) => { + for (name, a) in a.cases.iter() { + if let Some(b) = b.cases.get(name) { + // Covariant subtype on the case type + if !Self::is_optional_subtype_of(a.ty, at, b.ty, bt) { + return false; + } + } else if let Some(refines) = &a.refines { + if !b.cases.contains_key(refines) { + // The refinement case is not in the supertype + return false; + } + } else { + // This case is not in the supertype and there is no + // default + return false; + } + } + true + } + (Self::List(a), Self::List(b)) | (Self::Option(a), Self::Option(b)) => { + ComponentValType::internal_is_subtype_of(a, at, b, bt) + } + (Self::Tuple(a), Self::Tuple(b)) => { + if a.types.len() != b.types.len() { + return false; + } + a.types + .iter() + .zip(b.types.iter()) + .all(|(a, b)| ComponentValType::internal_is_subtype_of(a, at, b, bt)) + } + (Self::Union(a), Self::Union(b)) => { + if a.types.len() != b.types.len() { + return false; + } + a.types + .iter() + .zip(b.types.iter()) + .all(|(a, b)| ComponentValType::internal_is_subtype_of(a, at, b, bt)) + } + (Self::Flags(a), Self::Flags(b)) | (Self::Enum(a), Self::Enum(b)) => a.is_subset(b), + (Self::Result { ok: ao, err: ae }, Self::Result { ok: bo, err: be }) => { + Self::is_optional_subtype_of(*ao, at, *bo, bt) + && Self::is_optional_subtype_of(*ae, at, *be, bt) + } + _ => false, + } + } + + pub(crate) fn type_size(&self) -> usize { + match self { + Self::Primitive(_) => 1, + Self::Flags(_) | Self::Enum(_) => 1, + Self::Record(r) => r.type_size, + Self::Variant(v) => v.type_size, + Self::Tuple(t) => t.type_size, + Self::Union(u) => u.type_size, + Self::List(ty) | Self::Option(ty) => ty.type_size(), + Self::Result { ok, err } => { + ok.map(|ty| ty.type_size()).unwrap_or(1) + err.map(|ty| ty.type_size()).unwrap_or(1) + } + } + } + + fn is_optional_subtype_of( + a: Option, + at: &TypeList, + b: Option, + bt: &TypeList, + ) -> bool { + match (a, b) { + (None, None) | (Some(_), None) => true, + (None, Some(_)) => false, + (Some(a), Some(b)) => ComponentValType::internal_is_subtype_of(&a, at, &b, bt), + } + } + fn push_wasm_types(&self, types: &TypeList, lowered_types: &mut LoweredTypes) -> bool { + match self { + Self::Primitive(ty) => push_primitive_wasm_types(ty, lowered_types), + Self::Record(r) => r + .fields + .iter() + .all(|(_, ty)| ty.push_wasm_types(types, lowered_types)), + Self::Variant(v) => Self::push_variant_wasm_types( + v.cases.iter().filter_map(|(_, case)| case.ty.as_ref()), + types, + lowered_types, + ), + Self::List(_) => lowered_types.push(ValType::I32) && lowered_types.push(ValType::I32), + Self::Tuple(t) => t + .types + .iter() + .all(|ty| ty.push_wasm_types(types, lowered_types)), + Self::Flags(names) => { + (0..(names.len() + 31) / 32).all(|_| lowered_types.push(ValType::I32)) + } + Self::Enum(_) => lowered_types.push(ValType::I32), + Self::Union(u) => Self::push_variant_wasm_types(u.types.iter(), types, lowered_types), + Self::Option(ty) => { + Self::push_variant_wasm_types([ty].into_iter(), types, lowered_types) + } + Self::Result { ok, err } => { + Self::push_variant_wasm_types(ok.iter().chain(err.iter()), types, lowered_types) + } + } + } + + fn push_variant_wasm_types<'a>( + cases: impl Iterator, + types: &TypeList, + lowered_types: &mut LoweredTypes, + ) -> bool { + // Push the discriminant + if !lowered_types.push(ValType::I32) { + return false; + } + + let start = lowered_types.len(); + + for ty in cases { + let mut temp = LoweredTypes::new(lowered_types.max); + + if !ty.push_wasm_types(types, &mut temp) { + return false; + } + + for (i, ty) in temp.iter().enumerate() { + match lowered_types.get_mut(start + i) { + Some(prev) => *prev = Self::join_types(*prev, ty), + None => { + if !lowered_types.push(ty) { + return false; + } + } + } + } + } + + true + } + + fn join_types(a: ValType, b: ValType) -> ValType { + use ValType::*; + + match (a, b) { + (I32, I32) | (I64, I64) | (F32, F32) | (F64, F64) => a, + (I32, F32) | (F32, I32) => I32, + (_, I64 | F64) | (I64 | F64, _) => I64, + _ => panic!("unexpected wasm type for canonical ABI"), + } + } +} + +#[allow(clippy::large_enum_variant)] +enum TypesKind { + Module(Arc), + Component(ComponentState), +} + +/// Represents the types known to a [`crate::Validator`] once validation has completed. +/// +/// The type information is returned via the [`crate::Validator::end`] method. +pub struct Types { + list: TypeList, + kind: TypesKind, +} + +#[derive(Clone, Copy)] +enum TypesRefKind<'a> { + Module(&'a Module), + Component(&'a ComponentState), +} + +/// Represents the types known to a [`crate::Validator`] during validation. +/// +/// Retrieved via the [`crate::Validator::types`] method. +#[derive(Clone, Copy)] +pub struct TypesRef<'a> { + list: &'a TypeList, + kind: TypesRefKind<'a>, +} + +impl<'a> TypesRef<'a> { + pub(crate) fn from_module(types: &'a TypeList, module: &'a Module) -> Self { + Self { + list: types, + kind: TypesRefKind::Module(module), + } + } + + pub(crate) fn from_component(types: &'a TypeList, component: &'a ComponentState) -> Self { + Self { + list: types, + kind: TypesRefKind::Component(component), + } + } + + fn types(&self, core: bool) -> Option<&'a [TypeId]> { + Some(match &self.kind { + TypesRefKind::Module(module) => { + if core { + &module.types + } else { + return None; + } + } + TypesRefKind::Component(component) => { + if core { + &component.core_types + } else { + &component.types + } + } + }) + } + + /// Gets a type based on its type id. + /// + /// Returns `None` if the type id is unknown. + pub fn type_from_id(&self, id: TypeId) -> Option<&'a Type> { + self.list.get(id.index) + } + + /// Gets a type id from a type index. + /// + /// Returns `None` if the type index is out of bounds or the type has not + /// been parsed yet. + pub fn id_from_type_index(&self, index: u32, core: bool) -> Option { + self.types(core)?.get(index as usize).copied() + } + + /// Gets a type at the given type index. + /// + /// Returns `None` if the type index is out of bounds or the type has not + /// been parsed yet. + pub fn type_at(&self, index: u32, core: bool) -> Option<&'a Type> { + self.type_from_id(*self.types(core)?.get(index as usize)?) + } + + /// Gets a defined core function type at the given type index. + /// + /// Returns `None` if the type index is out of bounds or the type has not + /// been parsed yet. + pub fn func_type_at(&self, index: u32) -> Option<&'a FuncType> { + match self.type_at(index, true)? { + Type::Func(ty) => Some(ty), + _ => None, + } + } + + /// Gets the type of a table at the given table index. + /// + /// Returns `None` if the type index is out of bounds or the type has not + /// been parsed yet. + pub fn table_at(&self, index: u32) -> Option { + let tables = match &self.kind { + TypesRefKind::Module(module) => &module.tables, + TypesRefKind::Component(component) => &component.core_tables, + }; + + tables.get(index as usize).copied() + } + + /// Gets the type of a memory at the given memory index. + /// + /// Returns `None` if the type index is out of bounds or the type has not + /// been parsed yet. + pub fn memory_at(&self, index: u32) -> Option { + let memories = match &self.kind { + TypesRefKind::Module(module) => &module.memories, + TypesRefKind::Component(component) => &component.core_memories, + }; + + memories.get(index as usize).copied() + } + + /// Gets the type of a global at the given global index. + /// + /// Returns `None` if the type index is out of bounds or the type has not + /// been parsed yet. + pub fn global_at(&self, index: u32) -> Option { + let globals = match &self.kind { + TypesRefKind::Module(module) => &module.globals, + TypesRefKind::Component(component) => &component.core_globals, + }; + + globals.get(index as usize).copied() + } + + /// Gets the type of a tag at the given tag index. + /// + /// Returns `None` if the type index is out of bounds or the type has not + /// been parsed yet. + pub fn tag_at(&self, index: u32) -> Option<&'a FuncType> { + let tags = match &self.kind { + TypesRefKind::Module(module) => &module.tags, + TypesRefKind::Component(component) => &component.core_tags, + }; + + Some( + self.list[*tags.get(index as usize)?] + .as_func_type() + .unwrap(), + ) + } + + /// Gets the type of a core function at the given function index. + /// + /// Returns `None` if the type index is out of bounds or the type has not + /// been parsed yet. + pub fn function_at(&self, index: u32) -> Option<&'a FuncType> { + let id = match &self.kind { + TypesRefKind::Module(module) => { + &module.types[*module.functions.get(index as usize)? as usize] + } + TypesRefKind::Component(component) => component.core_funcs.get(index as usize)?, + }; + + match &self.list[*id] { + Type::Func(ty) => Some(ty), + _ => None, + } + } + + /// Gets the type of an element segment at the given element segment index. + /// + /// Returns `None` if the type index is out of bounds or the type has not + /// been parsed yet. + pub fn element_at(&self, index: u32) -> Option { + match &self.kind { + TypesRefKind::Module(module) => module.element_types.get(index as usize).copied(), + TypesRefKind::Component(_) => None, + } + } + + /// Gets the type of a component function at the given function index. + /// + /// Returns `None` if the type index is out of bounds or the type has not + /// been parsed yet. + pub fn component_function_at(&self, index: u32) -> Option<&'a ComponentFuncType> { + match &self.kind { + TypesRefKind::Module(_) => None, + TypesRefKind::Component(component) => Some( + self.list[*component.funcs.get(index as usize)?] + .as_component_func_type() + .unwrap(), + ), + } + } + + /// Gets the type of a module at the given module index. + /// + /// Returns `None` if the type index is out of bounds or the type has not + /// been parsed yet. + pub fn module_at(&self, index: u32) -> Option<&'a ModuleType> { + match &self.kind { + TypesRefKind::Module(_) => None, + TypesRefKind::Component(component) => Some( + self.list[*component.core_modules.get(index as usize)?] + .as_module_type() + .unwrap(), + ), + } + } + + /// Gets the type of a module instance at the given module instance index. + /// + /// Returns `None` if the type index is out of bounds or the type has not + /// been parsed yet. + pub fn instance_at(&self, index: u32) -> Option<&'a InstanceType> { + match &self.kind { + TypesRefKind::Module(_) => None, + TypesRefKind::Component(component) => { + let id = component.core_instances.get(index as usize)?; + match &self.list[*id] { + Type::Instance(ty) => Some(ty), + _ => None, + } + } + } + } + + /// Gets the type of a component at the given component index. + /// + /// Returns `None` if the type index is out of bounds or the type has not + /// been parsed yet. + pub fn component_at(&self, index: u32) -> Option<&'a ComponentType> { + match &self.kind { + TypesRefKind::Module(_) => None, + TypesRefKind::Component(component) => Some( + self.list[*component.components.get(index as usize)?] + .as_component_type() + .unwrap(), + ), + } + } + + /// Gets the type of an component instance at the given component instance index. + /// + /// Returns `None` if the type index is out of bounds or the type has not + /// been parsed yet. + pub fn component_instance_at(&self, index: u32) -> Option<&'a ComponentInstanceType> { + match &self.kind { + TypesRefKind::Module(_) => None, + TypesRefKind::Component(component) => { + let id = component.instances.get(index as usize)?; + match &self.list[*id] { + Type::ComponentInstance(ty) => Some(ty), + _ => None, + } + } + } + } + + /// Gets the type of a value at the given value index. + /// + /// Returns `None` if the type index is out of bounds or the type has not + /// been parsed yet. + pub fn value_at(&self, index: u32) -> Option { + match &self.kind { + TypesRefKind::Module(_) => None, + TypesRefKind::Component(component) => { + component.values.get(index as usize).map(|(r, _)| *r) + } + } + } + + /// Gets the entity type for the given import. + pub fn entity_type_from_import(&self, import: &Import) -> Option { + match &self.kind { + TypesRefKind::Module(module) => Some(match import.ty { + TypeRef::Func(idx) => EntityType::Func(*module.types.get(idx as usize)?), + TypeRef::Table(ty) => EntityType::Table(ty), + TypeRef::Memory(ty) => EntityType::Memory(ty), + TypeRef::Global(ty) => EntityType::Global(ty), + TypeRef::Tag(ty) => EntityType::Tag(*module.types.get(ty.func_type_idx as usize)?), + }), + TypesRefKind::Component(_) => None, + } + } + + /// Gets the entity type from the given export. + pub fn entity_type_from_export(&self, export: &Export) -> Option { + match &self.kind { + TypesRefKind::Module(module) => Some(match export.kind { + ExternalKind::Func => EntityType::Func( + module.types[*module.functions.get(export.index as usize)? as usize], + ), + ExternalKind::Table => { + EntityType::Table(*module.tables.get(export.index as usize)?) + } + ExternalKind::Memory => { + EntityType::Memory(*module.memories.get(export.index as usize)?) + } + ExternalKind::Global => { + EntityType::Global(*module.globals.get(export.index as usize)?) + } + ExternalKind::Tag => EntityType::Tag( + module.types[*module.functions.get(export.index as usize)? as usize], + ), + }), + TypesRefKind::Component(_) => None, + } + } + + /// Gets the component entity type for the given component import. + pub fn component_entity_type_from_import( + &self, + import: &ComponentImport, + ) -> Option { + match &self.kind { + TypesRefKind::Module(_) => None, + TypesRefKind::Component(component) => Some(match import.ty { + ComponentTypeRef::Module(idx) => { + ComponentEntityType::Module(*component.core_types.get(idx as usize)?) + } + ComponentTypeRef::Func(idx) => { + ComponentEntityType::Func(*component.types.get(idx as usize)?) + } + ComponentTypeRef::Value(ty) => ComponentEntityType::Value(match ty { + crate::ComponentValType::Primitive(ty) => ComponentValType::Primitive(ty), + crate::ComponentValType::Type(idx) => { + ComponentValType::Type(*component.types.get(idx as usize)?) + } + }), + ComponentTypeRef::Type(_, idx) => { + ComponentEntityType::Type(*component.types.get(idx as usize)?) + } + ComponentTypeRef::Instance(idx) => { + ComponentEntityType::Instance(*component.types.get(idx as usize)?) + } + ComponentTypeRef::Component(idx) => { + ComponentEntityType::Component(*component.types.get(idx as usize)?) + } + }), + } + } + + /// Gets the component entity type from the given component export. + pub fn component_entity_type_from_export( + &self, + export: &ComponentExport, + ) -> Option { + match &self.kind { + TypesRefKind::Module(_) => None, + TypesRefKind::Component(component) => Some(match export.kind { + ComponentExternalKind::Module => { + ComponentEntityType::Module(*component.core_modules.get(export.index as usize)?) + } + ComponentExternalKind::Func => { + ComponentEntityType::Func(*component.funcs.get(export.index as usize)?) + } + ComponentExternalKind::Value => ComponentEntityType::Value( + component + .values + .get(export.index as usize) + .map(|(r, _)| *r)?, + ), + ComponentExternalKind::Type => { + ComponentEntityType::Type(*component.types.get(export.index as usize)?) + } + ComponentExternalKind::Instance => { + ComponentEntityType::Instance(*component.instances.get(export.index as usize)?) + } + ComponentExternalKind::Component => ComponentEntityType::Component( + *component.components.get(export.index as usize)?, + ), + }), + } + } +} + +impl Types { + pub(crate) fn from_module(types: TypeList, module: Arc) -> Self { + Self { + list: types, + kind: TypesKind::Module(module), + } + } + + pub(crate) fn from_component(types: TypeList, component: ComponentState) -> Self { + Self { + list: types, + kind: TypesKind::Component(component), + } + } + + /// Gets a reference to this validation type information. + pub fn as_ref(&self) -> TypesRef { + TypesRef { + list: &self.list, + kind: match &self.kind { + TypesKind::Module(module) => TypesRefKind::Module(module), + TypesKind::Component(component) => TypesRefKind::Component(component), + }, + } + } + + /// Gets a type based on its type id. + /// + /// Returns `None` if the type id is unknown. + pub fn type_from_id(&self, id: TypeId) -> Option<&Type> { + self.as_ref().type_from_id(id) + } + + /// Gets a type id from a type index. + /// + /// Returns `None` if the type index is out of bounds. + pub fn id_from_type_index(&self, index: u32, core: bool) -> Option { + self.as_ref().id_from_type_index(index, core) + } + + /// Gets a type at the given type index. + /// + /// Returns `None` if the index is out of bounds. + pub fn type_at(&self, index: u32, core: bool) -> Option<&Type> { + self.as_ref().type_at(index, core) + } + + /// Gets a defined core function type at the given type index. + /// + /// Returns `None` if the index is out of bounds. + pub fn func_type_at(&self, index: u32) -> Option<&FuncType> { + self.as_ref().func_type_at(index) + } + + /// Gets the count of core types. + pub fn type_count(&self) -> usize { + match &self.kind { + TypesKind::Module(module) => module.types.len(), + TypesKind::Component(component) => component.core_types.len(), + } + } + + /// Gets the type of a table at the given table index. + /// + /// Returns `None` if the index is out of bounds. + pub fn table_at(&self, index: u32) -> Option { + self.as_ref().table_at(index) + } + + /// Gets the count of imported and defined tables. + pub fn table_count(&self) -> usize { + match &self.kind { + TypesKind::Module(module) => module.tables.len(), + TypesKind::Component(component) => component.core_tables.len(), + } + } + + /// Gets the type of a memory at the given memory index. + /// + /// Returns `None` if the index is out of bounds. + pub fn memory_at(&self, index: u32) -> Option { + self.as_ref().memory_at(index) + } + + /// Gets the count of imported and defined memories. + pub fn memory_count(&self) -> usize { + match &self.kind { + TypesKind::Module(module) => module.memories.len(), + TypesKind::Component(component) => component.core_memories.len(), + } + } + + /// Gets the type of a global at the given global index. + /// + /// Returns `None` if the index is out of bounds. + pub fn global_at(&self, index: u32) -> Option { + self.as_ref().global_at(index) + } + + /// Gets the count of imported and defined globals. + pub fn global_count(&self) -> usize { + match &self.kind { + TypesKind::Module(module) => module.globals.len(), + TypesKind::Component(component) => component.core_globals.len(), + } + } + + /// Gets the type of a tag at the given tag index. + /// + /// Returns `None` if the index is out of bounds. + pub fn tag_at(&self, index: u32) -> Option<&FuncType> { + self.as_ref().tag_at(index) + } + + /// Gets the count of imported and defined tags. + pub fn tag_count(&self) -> usize { + match &self.kind { + TypesKind::Module(module) => module.tags.len(), + TypesKind::Component(component) => component.core_tags.len(), + } + } + + /// Gets the type of a core function at the given function index. + /// + /// Returns `None` if the index is out of bounds. + pub fn function_at(&self, index: u32) -> Option<&FuncType> { + self.as_ref().function_at(index) + } + + /// Gets the count of imported and defined core functions. + /// + /// The count also includes aliased core functions in components. + pub fn function_count(&self) -> usize { + match &self.kind { + TypesKind::Module(module) => module.functions.len(), + TypesKind::Component(component) => component.core_funcs.len(), + } + } + + /// Gets the type of an element segment at the given element segment index. + /// + /// Returns `None` if the index is out of bounds. + pub fn element_at(&self, index: u32) -> Option { + self.as_ref().element_at(index) + } + + /// Gets the count of element segments. + pub fn element_count(&self) -> usize { + match &self.kind { + TypesKind::Module(module) => module.element_types.len(), + TypesKind::Component(_) => 0, + } + } + + /// Gets the type of a component function at the given function index. + /// + /// Returns `None` if the index is out of bounds. + pub fn component_function_at(&self, index: u32) -> Option<&ComponentFuncType> { + self.as_ref().component_function_at(index) + } + + /// Gets the count of imported, exported, or aliased component functions. + pub fn component_function_count(&self) -> usize { + match &self.kind { + TypesKind::Module(_) => 0, + TypesKind::Component(component) => component.funcs.len(), + } + } + + /// Gets the type of a module at the given module index. + /// + /// Returns `None` if the index is out of bounds. + pub fn module_at(&self, index: u32) -> Option<&ModuleType> { + self.as_ref().module_at(index) + } + + /// Gets the count of imported, exported, or aliased modules. + pub fn module_count(&self) -> usize { + match &self.kind { + TypesKind::Module(_) => 0, + TypesKind::Component(component) => component.core_modules.len(), + } + } + + /// Gets the type of a module instance at the given module instance index. + /// + /// Returns `None` if the index is out of bounds. + pub fn instance_at(&self, index: u32) -> Option<&InstanceType> { + self.as_ref().instance_at(index) + } + + /// Gets the count of imported, exported, or aliased core module instances. + pub fn instance_count(&self) -> usize { + match &self.kind { + TypesKind::Module(_) => 0, + TypesKind::Component(component) => component.core_instances.len(), + } + } + + /// Gets the type of a component at the given component index. + /// + /// Returns `None` if the index is out of bounds. + pub fn component_at(&self, index: u32) -> Option<&ComponentType> { + self.as_ref().component_at(index) + } + + /// Gets the count of imported, exported, or aliased components. + pub fn component_count(&self) -> usize { + match &self.kind { + TypesKind::Module(_) => 0, + TypesKind::Component(component) => component.components.len(), + } + } + + /// Gets the type of an component instance at the given component instance index. + /// + /// Returns `None` if the index is out of bounds. + pub fn component_instance_at(&self, index: u32) -> Option<&ComponentInstanceType> { + self.as_ref().component_instance_at(index) + } + + /// Gets the count of imported, exported, or aliased component instances. + pub fn component_instance_count(&self) -> usize { + match &self.kind { + TypesKind::Module(_) => 0, + TypesKind::Component(component) => component.instances.len(), + } + } + + /// Gets the type of a value at the given value index. + /// + /// Returns `None` if the index is out of bounds. + pub fn value_at(&self, index: u32) -> Option { + self.as_ref().value_at(index) + } + + /// Gets the count of imported, exported, or aliased values. + pub fn value_count(&self) -> usize { + match &self.kind { + TypesKind::Module(_) => 0, + TypesKind::Component(component) => component.values.len(), + } + } + + /// Gets the entity type from the given import. + pub fn entity_type_from_import(&self, import: &Import) -> Option { + self.as_ref().entity_type_from_import(import) + } + + /// Gets the entity type from the given export. + pub fn entity_type_from_export(&self, export: &Export) -> Option { + self.as_ref().entity_type_from_export(export) + } + + /// Gets the component entity type for the given component import. + pub fn component_entity_type_from_import( + &self, + import: &ComponentImport, + ) -> Option { + self.as_ref().component_entity_type_from_import(import) + } + + /// Gets the component entity type from the given component export. + pub fn component_entity_type_from_export( + &self, + export: &ComponentExport, + ) -> Option { + self.as_ref().component_entity_type_from_export(export) + } +} + +/// This is a type which mirrors a subset of the `Vec` API, but is intended +/// to be able to be cheaply snapshotted and cloned. +/// +/// When each module's code sections start we "commit" the current list of types +/// in the global list of types. This means that the temporary `cur` vec here is +/// pushed onto `snapshots` and wrapped up in an `Arc`. At that point we clone +/// this entire list (which is then O(modules), not O(types in all modules)) and +/// pass out as a context to each function validator. +/// +/// Otherwise, though, this type behaves as if it were a large `Vec`, but +/// it's represented by lists of contiguous chunks. +pub(crate) struct SnapshotList { + // All previous snapshots, the "head" of the list that this type represents. + // The first entry in this pair is the starting index for all elements + // contained in the list, and the second element is the list itself. Note + // the `Arc` wrapper around sub-lists, which makes cloning time for this + // `SnapshotList` O(snapshots) rather than O(snapshots_total), which for + // us in this context means the number of modules, not types. + // + // Note that this list is sorted least-to-greatest in order of the index for + // binary searching. + snapshots: Vec<(usize, Arc>)>, + + // This is the total length of all lists in the `snapshots` array. + snapshots_total: usize, + + // The current list of types for the current snapshot that are being built. + cur: Vec, +} + +impl SnapshotList { + /// Same as `<&[T]>::get` + pub(crate) fn get(&self, index: usize) -> Option<&T> { + // Check to see if this index falls on our local list + if index >= self.snapshots_total { + return self.cur.get(index - self.snapshots_total); + } + // ... and failing that we do a binary search to figure out which bucket + // it's in. Note the `i-1` in the `Err` case because if we don't find an + // exact match the type is located in the previous bucket. + let i = match self.snapshots.binary_search_by_key(&index, |(i, _)| *i) { + Ok(i) => i, + Err(i) => i - 1, + }; + let (len, list) = &self.snapshots[i]; + Some(&list[index - len]) + } + + /// Same as `<&mut [T]>::get_mut`, except only works for indexes into the + /// current snapshot being built. + /// + /// # Panics + /// + /// Panics if an index is passed in which falls within the + /// previously-snapshotted list of types. This should never happen in our + /// context and the panic is intended to weed out possible bugs in + /// wasmparser. + pub(crate) fn get_mut(&mut self, index: usize) -> Option<&mut T> { + if index >= self.snapshots_total { + return self.cur.get_mut(index - self.snapshots_total); + } + panic!("cannot get a mutable reference in snapshotted part of list") + } + + /// Same as `Vec::push` + pub(crate) fn push(&mut self, val: T) { + self.cur.push(val); + } + + /// Same as `<[T]>::len` + pub(crate) fn len(&self) -> usize { + self.cur.len() + self.snapshots_total + } + + /// Reserve space for an additional count of items. + pub(crate) fn reserve(&mut self, additional: usize) { + self.cur.reserve(additional); + } + + /// Commits previously pushed types into this snapshot vector, and returns a + /// clone of this list. + /// + /// The returned `SnapshotList` can be used to access all the same types as + /// this list itself. This list also is not changed (from an external + /// perspective) and can continue to access all the same types. + pub(crate) fn commit(&mut self) -> SnapshotList { + // If the current chunk has new elements, commit them in to an + // `Arc`-wrapped vector in the snapshots list. Note the `shrink_to_fit` + // ahead of time to hopefully keep memory usage lower than it would + // otherwise be. + let len = self.cur.len(); + if len > 0 { + self.cur.shrink_to_fit(); + self.snapshots + .push((self.snapshots_total, Arc::new(mem::take(&mut self.cur)))); + self.snapshots_total += len; + } + SnapshotList { + snapshots: self.snapshots.clone(), + snapshots_total: self.snapshots_total, + cur: Vec::new(), + } + } +} + +impl std::ops::Index for SnapshotList { + type Output = T; + + fn index(&self, index: usize) -> &T { + self.get(index).unwrap() + } +} + +impl std::ops::IndexMut for SnapshotList { + fn index_mut(&mut self, index: usize) -> &mut T { + self.get_mut(index).unwrap() + } +} + +impl std::ops::Index for SnapshotList { + type Output = T; + + fn index(&self, id: TypeId) -> &T { + self.get(id.index).unwrap() + } +} + +impl std::ops::IndexMut for SnapshotList { + fn index_mut(&mut self, id: TypeId) -> &mut T { + self.get_mut(id.index).unwrap() + } +} + +impl Default for SnapshotList { + fn default() -> SnapshotList { + SnapshotList { + snapshots: Vec::new(), + snapshots_total: 0, + cur: Vec::new(), + } + } +} + +/// A snapshot list of types. +pub(crate) type TypeList = SnapshotList; diff --git a/crates/wasmtime/Cargo.toml b/crates/wasmtime/Cargo.toml index 0e9f5d617..4a70d3a80 100644 --- a/crates/wasmtime/Cargo.toml +++ b/crates/wasmtime/Cargo.toml @@ -22,12 +22,12 @@ wasmtime-cranelift = { path = "../cranelift", version = "=2.0.0", optional = tru wasmtime-component-macro = { path = "../component-macro", version = "=2.0.0", optional = true } wasmtime-component-util = { path = "../component-util", version = "=2.0.0", optional = true } target-lexicon = { version = "0.12.0", default-features = false } -wasmparser = "0.89.0" +wasmparser = { path = "../wasmparser", version = "0.89.0"} anyhow = "1.0.19" libc = "0.2" cfg-if = "1.0" log = "0.4.8" -wat = { version = "1.0.47", optional = true } +wat = { path = "../wat", version = "1.0.47", optional = true } serde = { version = "1.0.94", features = ["derive"] } bincode = "1.2.1" indexmap = "1.6" diff --git a/crates/wasmtime/src/engine.rs b/crates/wasmtime/src/engine.rs index 85c3aeb99..a9c88a563 100644 --- a/crates/wasmtime/src/engine.rs +++ b/crates/wasmtime/src/engine.rs @@ -509,6 +509,7 @@ impl Engine { "has_avx512vl" => Some(std::is_x86_feature_detected!("avx512vl")), "has_avx512vbmi" => Some(std::is_x86_feature_detected!("avx512vbmi")), "has_lzcnt" => Some(std::is_x86_feature_detected!("lzcnt")), + "has_pkru" => Some(std::is_x86_feature_detected!("xsaves")), // fall through to the very bottom to indicate that support is // not enabled to test whether this feature is enabled on the diff --git a/crates/wasmtime/src/func.rs b/crates/wasmtime/src/func.rs index 5fd85a6f0..1730c4c15 100644 --- a/crates/wasmtime/src/func.rs +++ b/crates/wasmtime/src/func.rs @@ -335,9 +335,11 @@ impl Func { ty: FuncType, func: impl Fn(Caller<'_, T>, &[Val], &mut [Val]) -> Result<(), Trap> + Send + Sync + 'static, ) -> Self { + // println!("Func new 1"); let ty_clone = ty.clone(); unsafe { Func::new_unchecked(store, ty, move |caller, values| { + // println!("Func new 2"); Func::invoke(caller, &ty_clone, values, &func) }) } @@ -823,14 +825,17 @@ impl Func { trampoline: VMTrampoline, params_and_returns: *mut ValRaw, ) -> Result<(), Trap> { + // println!("call_unchecked_raw"); invoke_wasm_and_catch_traps(store, |caller| { + // println!("before call_unchecked_raw invoke_wasm_and_catch_traps"); let trampoline = wasmtime_runtime::prepare_host_to_wasm_trampoline(caller, trampoline); trampoline( anyfunc.as_ref().vmctx, caller, anyfunc.as_ref().func_ptr.as_ptr(), params_and_returns, - ) + ); + // println!("after call_unchecked_raw invoke_wasm_and_catch_traps"); }) } @@ -1000,6 +1005,7 @@ impl Func { ) -> Self { let anyfunc = export.anyfunc.as_ref(); let trampoline = store.lookup_trampoline(&*anyfunc); + // println!("Func from_wasmtime_function"); Func::from_func_kind(FuncKind::StoreOwned { trampoline, export }, store) } @@ -1046,8 +1052,9 @@ impl Func { val_vec.extend((0..ty.results().len()).map(|_| Val::null())); let (params, results) = val_vec.split_at_mut(nparams); + // println!("before Func invoke"); func(caller.sub_caller(), params, results)?; - + // println!("after Func invoke"); // See the comment in `Func::call_impl`'s `write_params` function. if ty.as_wasm_func_type().externref_returns_count() > caller @@ -1228,7 +1235,7 @@ pub(crate) fn invoke_wasm_and_catch_traps( ) -> Result<(), Trap> { unsafe { let exit = enter_wasm(store); - + // println!("before invoke_wasm_and_catch_traps"); if let Err(trap) = store.0.call_hook(CallHook::CallingWasm) { exit_wasm(store, exit); return Err(trap); @@ -1241,6 +1248,7 @@ pub(crate) fn invoke_wasm_and_catch_traps( ); exit_wasm(store, exit); store.0.call_hook(CallHook::ReturningFromWasm)?; + // println!("after invoke_wasm_and_catch_traps"); result.map_err(|t| Trap::from_runtime_box(store.0, t)) } } @@ -1688,6 +1696,7 @@ impl Caller<'_, T> { // back to themselves. If this caller doesn't have that `host_state` // then it probably means it was a host-created object like `Func::new` // which doesn't have any exports we want to return anyway. + // println!("Caller get_export {name}"); self.caller .host_state() .downcast_ref::()? @@ -2005,15 +2014,21 @@ impl HostFunc { func: impl Fn(Caller<'_, T>, &mut [ValRaw]) -> Result<(), Trap> + Send + Sync + 'static, ) -> Self { let func = move |caller_vmctx, values: &mut [ValRaw]| { + // println!("HostFunc new_unchecked before Caller::::with"); Caller::::with(caller_vmctx, |mut caller| { + // println!("HostFunc new_unchecked before call_hook 1"); caller.store.0.call_hook(CallHook::CallingHost)?; + // println!("HostFunc new_unchecked after call_hook 1"); let result = func(caller.sub_caller(), values)?; + // println!("HostFunc new_unchecked before call_hook 2"); caller.store.0.call_hook(CallHook::ReturningFromHost)?; + // println!("HostFunc new_unchecked after call_hook 2"); Ok(result) }) }; let (ctx, signature, trampoline) = crate::trampoline::create_function(&ty, func, engine) .expect("failed to create function"); + // println!("HostFunc new_unchecked after trampoline::create_function"); HostFunc::_new(engine, ctx, signature, trampoline) } @@ -2052,6 +2067,7 @@ impl HostFunc { pub unsafe fn to_func(self: &Arc, store: &mut StoreOpaque) -> Func { self.validate_store(store); let me = self.clone(); + // println!("HostFunc to_func"); Func::from_func_kind(FuncKind::SharedHost(me), store) } @@ -2075,12 +2091,14 @@ impl HostFunc { /// `StoreOpaque::rooted_host_funcs`. pub unsafe fn to_func_store_rooted(self: &Arc, store: &mut StoreOpaque) -> Func { self.validate_store(store); + // println!("HostFunc to_func_store_rooted"); Func::from_func_kind(FuncKind::RootedHost(RootedHostFunc::new(self)), store) } /// Same as [`HostFunc::to_func`], different ownership. unsafe fn into_func(self, store: &mut StoreOpaque) -> Func { self.validate_store(store); + // println!("HostFunc into_func"); Func::from_func_kind(FuncKind::Host(Box::new(self)), store) } diff --git a/crates/wasmtime/src/func/typed.rs b/crates/wasmtime/src/func/typed.rs index 83565829e..626e5a082 100644 --- a/crates/wasmtime/src/func/typed.rs +++ b/crates/wasmtime/src/func/typed.rs @@ -163,7 +163,7 @@ where // other side of a C++ shim, so it can never be inlined enough to make // the memory go away, so the size matters here for performance. let mut captures = (func, MaybeUninit::uninit(), params, false); - + // println!("call_raw"); let result = invoke_wasm_and_catch_traps(store, |caller| { let (anyfunc, ret, params, returned) = &mut captures; let anyfunc = anyfunc.as_ref(); diff --git a/crates/wasmtime/src/instance.rs b/crates/wasmtime/src/instance.rs index 898a963fc..75832f128 100644 --- a/crates/wasmtime/src/instance.rs +++ b/crates/wasmtime/src/instance.rs @@ -408,6 +408,7 @@ impl Instance { /// instantiating a module faster, but also means this method requires a /// mutable context. pub fn get_export(&self, mut store: impl AsContextMut, name: &str) -> Option { + // println!("Instance get_export {name}"); self._get_export(store.as_context_mut().0, name) } diff --git a/crates/wasmtime/src/isolated_memory.rs b/crates/wasmtime/src/isolated_memory.rs new file mode 100644 index 000000000..94b5351de --- /dev/null +++ b/crates/wasmtime/src/isolated_memory.rs @@ -0,0 +1,75 @@ +//! Memory isolation + +use std::cell::RefCell; +use wasmtime_runtime::Pku; +use wasmtime_runtime::VMMemoryDefinition; + +/// A simple struct of isolated memory +#[derive(Debug)] +pub struct IsolatedMomery {} + +thread_local!(static MOMERY: RefCell> = RefCell::new(Vec::new())); + +impl IsolatedMomery { + /// Construct a new init instance of 'IsolatedMomery'. + pub fn new() -> Self { + Self {} + } + + /// Crate memory domain. + pub fn hook_domain(vm: &VMMemoryDefinition, start: usize, len: usize, prot: i64) { + let pkey = Pku::pkey_isolated(vm, start, len, prot); + MOMERY.with(|m| { + m.borrow_mut().push(MomeryMap::new(start, len, prot, pkey)); + }); + } + + /// Redo memory isolation, becouse wasmtime grow function mmap wasm memory in new virtual memory range. + pub fn hook_memory(vm: &VMMemoryDefinition) { + MOMERY.with(|m| { + for iter in m.take() { + let mmap = iter.get(); + Pku::pkey_mprotect(vm, mmap.0, mmap.1, mmap.2, mmap.3); + } + }); + } + + /// Transition to isolated domain. + pub fn hook_isolated_domain(pkey: i64) { + Pku::set_pkey(pkey, 0); + } + + /// Transition to normal domain. + pub fn hook_normal_domain(pkey: i64) { + let prot: i32 = 0x1 | 0x2; + Pku::set_pkey(pkey, prot); + } + + /// Trampline to transition domain. + pub fn hook_transition(pkey: i64, prot: i32) { + Pku::set_pkey(pkey, prot); + } +} + +#[derive(Debug)] +pub struct MomeryMap { + offset: usize, + len: usize, + prot: i64, + pkey: i64, +} + +impl MomeryMap { + pub fn new(offset: usize, len: usize, prot: i64, pkey: i64) -> Self { + Self { + offset, + len, + prot, + pkey, + } + } + + pub fn get(&self) -> (usize, usize, i64, i64) { + (self.offset, self.len, self.prot, self.pkey) + } +} diff --git a/crates/wasmtime/src/lib.rs b/crates/wasmtime/src/lib.rs index c86fbeab1..47b22dfa4 100644 --- a/crates/wasmtime/src/lib.rs +++ b/crates/wasmtime/src/lib.rs @@ -404,6 +404,7 @@ mod trampoline; mod trap; mod types; mod values; +mod isolated_memory; pub use crate::config::*; pub use crate::engine::*; @@ -421,6 +422,7 @@ pub use crate::store::{AsContext, AsContextMut, CallHook, Store, StoreContext, S pub use crate::trap::*; pub use crate::types::*; pub use crate::values::*; +pub use crate::isolated_memory::IsolatedMomery; #[cfg(feature = "component-model")] pub mod component; diff --git a/crates/wasmtime/src/linker.rs b/crates/wasmtime/src/linker.rs index fd5230d1f..d35134be1 100644 --- a/crates/wasmtime/src/linker.rs +++ b/crates/wasmtime/src/linker.rs @@ -699,10 +699,12 @@ impl Linker { module_name, module, |store, func_ty, export_name, instance_pre| { + // println!("in Linker module command"); Func::new( store, func_ty.clone(), move |mut caller, params, results| { + // println!("before closure func before in Linker module Command Func::new"); // Create a new instance for this command execution. let instance = instance_pre.instantiate(&mut caller)?; @@ -716,7 +718,7 @@ impl Linker { .unwrap() .call(&mut caller, params, results) .map_err(|error| error.downcast::().unwrap())?; - + // println!("closure func after in Linker module Command Func::new"); Ok(()) }, ) @@ -821,11 +823,13 @@ impl Linker { let mut store = store.as_context_mut(); for export in module.exports() { if let Some(func_ty) = export.ty().func() { + // println!("before Linker command for loop"); let instance_pre = self.instantiate_pre(&mut store, module)?; let export_name = export.name().to_owned(); let func = mk_func(&mut store, func_ty, export_name, instance_pre); let key = self.import_key(module_name, Some(export.name())); self.insert(key, Definition::Extern(func.into()))?; + // println!("after Linker command for loop {}", export.name().to_owned()); } else if export.name() == "memory" && export.ty().memory().is_some() { // Allow an exported "memory" memory for now. } else if export.name() == "__indirect_function_table" && export.ty().table().is_some() diff --git a/crates/wasmtime/src/store.rs b/crates/wasmtime/src/store.rs index 05bf5d54e..acafdfcee 100644 --- a/crates/wasmtime/src/store.rs +++ b/crates/wasmtime/src/store.rs @@ -358,7 +358,8 @@ where T: std::ops::DerefMut, { pub fn new(mut store: T) -> Self { - drop(&mut store); + // drop(&mut store); + let _ = &mut store; #[cfg(debug_assertions)] { let prev_okay = store.externref_activations_table.set_gc_okay(false); @@ -703,6 +704,7 @@ impl Store { /// returns to host or wasm code as the trap propagates to the root call. #[cfg(feature = "async")] pub fn call_hook_async(&mut self, hook: impl CallHookHandler + Send + Sync + 'static) { + // println!("store call_hook_async"); self.inner.call_hook = Some(CallHookInner::Async(Box::new(hook))); } @@ -724,6 +726,7 @@ impl Store { &mut self, hook: impl FnMut(&mut T, CallHook) -> Result<(), Trap> + Send + Sync + 'static, ) { + // println!("store call_hook"); self.inner.call_hook = Some(CallHookInner::Sync(Box::new(hook))); } @@ -1095,6 +1098,7 @@ impl StoreInner { } pub fn call_hook(&mut self, s: CallHook) -> Result<(), Trap> { + // println!("StoreInner call_hook"); match &mut self.call_hook { Some(CallHookInner::Sync(hook)) => hook(&mut self.data, s), @@ -1994,7 +1998,8 @@ impl StoreInner { { self.epoch_deadline_behavior = EpochDeadline::YieldAndExtendDeadline { delta }; } - drop(delta); // suppress warning in non-async build + // drop(delta); // suppress warning in non-async build + let _ = delta; } fn get_epoch_deadline(&self) -> u64 { diff --git a/crates/wastlhw/.cargo-ok b/crates/wastlhw/.cargo-ok new file mode 100644 index 000000000..b5754e203 --- /dev/null +++ b/crates/wastlhw/.cargo-ok @@ -0,0 +1 @@ +ok \ No newline at end of file diff --git a/crates/wastlhw/.cargo_vcs_info.json b/crates/wastlhw/.cargo_vcs_info.json new file mode 100644 index 000000000..f0c99edd2 --- /dev/null +++ b/crates/wastlhw/.cargo_vcs_info.json @@ -0,0 +1,6 @@ +{ + "git": { + "sha1": "9dfdbc22a3370f340d30b79454b4782c1257797f" + }, + "path_in_vcs": "crates/wast" +} \ No newline at end of file diff --git a/crates/wastlhw/Cargo.toml b/crates/wastlhw/Cargo.toml new file mode 100644 index 000000000..5df80ef47 --- /dev/null +++ b/crates/wastlhw/Cargo.toml @@ -0,0 +1,51 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2021" +name = "wastlhw" +version = "46.0.0" +authors = ["Alex Crichton "] +description = """ +Customizable Rust parsers for the WebAssembly Text formats WAT and WAST +""" +homepage = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wast" +documentation = "https://docs.rs/wast" +readme = "README.md" +license = "Apache-2.0 WITH LLVM-exception" +repository = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wast" +resolver = "2" + +[[test]] +name = "parse-fail" +harness = false + +[dependencies.leb128] +version = "0.2" + +[dependencies.memchr] +version = "2.4.1" + +[dependencies.unicode-width] +version = "0.1.9" + +[dependencies.wasm-encoder] +version = "0.16.0" + +[dev-dependencies.anyhow] +version = "1.0" + +[dev-dependencies.rayon] +version = "1.0" + +[features] +default = ["wasm-module"] +wasm-module = [] diff --git a/crates/wastlhw/Cargo.toml.orig b/crates/wastlhw/Cargo.toml.orig new file mode 100644 index 000000000..0c2bb35c2 --- /dev/null +++ b/crates/wastlhw/Cargo.toml.orig @@ -0,0 +1,40 @@ +[package] +name = "wast" +version = "46.0.0" +authors = ["Alex Crichton "] +edition = "2021" +license = "Apache-2.0 WITH LLVM-exception" +readme = "README.md" +repository = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wast" +homepage = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wast" +documentation = "https://docs.rs/wast" +description = """ +Customizable Rust parsers for the WebAssembly Text formats WAT and WAST +""" + +[dependencies] +leb128 = "0.2" +unicode-width = "0.1.9" +memchr = "2.4.1" +wasm-encoder = { version = "0.16.0", path = "../wasm-encoder" } + +[dev-dependencies] +anyhow = "1.0" +rayon = "1.0" +wasmparser = { path = "../wasmparser" } +wat = { path = "../wat" } + +[features] +default = ['wasm-module'] + +# Includes default parsing support for `*.wat` and `*.wast` files (wasm +# modules). This isn't always needed though if you're parsing just an +# s-expression based format. If you'd like to slim down this dependency to just +# the lexer, parser framework, and token support, this feature can be disabled. +# +# This feature is turned on by default. +wasm-module = [] + +[[test]] +name = "parse-fail" +harness = false diff --git a/crates/wastlhw/LICENSE b/crates/wastlhw/LICENSE new file mode 100644 index 000000000..f9d81955f --- /dev/null +++ b/crates/wastlhw/LICENSE @@ -0,0 +1,220 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +--- LLVM Exceptions to the Apache 2.0 License ---- + +As an exception, if, as a result of your compiling your source code, portions +of this Software are embedded into an Object form of such source code, you +may redistribute such embedded portions in such Object form without complying +with the conditions of Sections 4(a), 4(b) and 4(d) of the License. + +In addition, if you combine or link compiled forms of this Software with +software that is licensed under the GPLv2 ("Combined Software") and if a +court of competent jurisdiction determines that the patent provision (Section +3), the indemnity provision (Section 9) or other Section of the License +conflicts with the conditions of the GPLv2, you may retroactively and +prospectively choose to deem waived or otherwise exclude such Section(s) of +the License, but only in their entirety and only with respect to the Combined +Software. + diff --git a/crates/wastlhw/README.md b/crates/wastlhw/README.md new file mode 100644 index 000000000..548a3630e --- /dev/null +++ b/crates/wastlhw/README.md @@ -0,0 +1,62 @@ +
      +

      wast

      + +A       Bytecode Alliance project + +

      + A Rust parser for the WebAssembly Text Format (WAT). +

      + +

      + Crates.io version + Download + docs.rs docs +

      +
      + + +## Usage + +Add this to your `Cargo.toml`: + +```toml +[dependencies] +wast = "22.0" +``` + +The intent of this crate is to provide utilities, combinators, and built-in +types to parse anything that looks like a WebAssembly s-expression. + +* Need to parse a `*.wat` file? +* Need to parse a `*.wast` file? +* Need to run test suite assertions from the official wasm test suite? +* Want to write an extension do the WebAssembly text format? + +If you'd like to do any of the above this crate might be right for you! You may +also want to check out the `wat` crate which provides a much more stable +interface if all you'd like to do is convert `*.wat` to `*.wasm`. + +## Cargo features + +By default this crate enables and exports support necessary to parse `*.wat` and +`*.wast` files, or in other words entire wasm modules. If you're using this +crate, however, to parse simply an s-expression wasm-related format (like +`*.witx` or `*.wit` perhaps) then you can disable the default set of features to +only include a lexer, the parsing framework, and a few basic token-related +parsers. + +```toml +[dependencies] +wast = { version = "22.0", default-features = false } +``` + +# License + +This project is licensed under the Apache 2.0 license with the LLVM exception. +See [LICENSE](LICENSE) for more details. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in this project by you, as defined in the Apache-2.0 license, +shall be dual licensed as above, without any additional terms or conditions. diff --git a/crates/wastlhw/src/component.rs b/crates/wastlhw/src/component.rs new file mode 100644 index 000000000..899baaa35 --- /dev/null +++ b/crates/wastlhw/src/component.rs @@ -0,0 +1,28 @@ +//! Types and support for parsing the component model text format. + +mod alias; +mod binary; +mod component; +mod custom; +mod expand; +mod export; +mod func; +mod import; +mod instance; +mod item_ref; +mod module; +mod resolve; +mod types; +mod wast; + +pub use self::alias::*; +pub use self::component::*; +pub use self::custom::*; +pub use self::export::*; +pub use self::func::*; +pub use self::import::*; +pub use self::instance::*; +pub use self::item_ref::*; +pub use self::module::*; +pub use self::types::*; +pub use self::wast::*; diff --git a/crates/wastlhw/src/component/alias.rs b/crates/wastlhw/src/component/alias.rs new file mode 100644 index 000000000..f862ddae4 --- /dev/null +++ b/crates/wastlhw/src/component/alias.rs @@ -0,0 +1,324 @@ +use crate::core::ExportKind; +use crate::kw; +use crate::parser::{Parse, Parser, Result}; +use crate::token::{Id, Index, NameAnnotation, Span}; + +/// A inline alias for component exported items. +#[derive(Debug)] +pub struct InlineExportAlias<'a> { + /// The instance to alias the export from. + pub instance: Index<'a>, + /// The name of the export to alias. + pub name: &'a str, +} + +impl<'a> Parse<'a> for InlineExportAlias<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + parser.parse::()?; + let instance = parser.parse()?; + let name = parser.parse()?; + Ok(Self { instance, name }) + } +} + +/// An alias to a core item. +#[derive(Debug)] +pub struct CoreAlias<'a> { + /// Where this `core alias` was defined. + pub span: Span, + /// An identifier that this alias is resolved with (optionally) for name + /// resolution. + pub id: Option>, + /// An optional name for this alias stored in the custom `name` section. + pub name: Option>, + /// The target of the alias. + pub target: CoreAliasTarget<'a>, +} + +impl<'a> CoreAlias<'a> { + /// Parses only an outer type alias. + pub fn parse_outer_type_alias(span: Span, parser: Parser<'a>) -> Result { + parser.parse::()?; + let outer = parser.parse()?; + let index = parser.parse()?; + + let (kind, id, name) = + parser.parens(|parser| Ok((parser.parse()?, parser.parse()?, parser.parse()?)))?; + + Ok(Self { + span, + target: CoreAliasTarget::Outer { outer, index, kind }, + id, + name, + }) + } +} + +impl<'a> Parse<'a> for CoreAlias<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + parser.parse::()?; + + let mut l = parser.lookahead1(); + + if l.peek::() { + // As only types are supported for outer core aliases, delegate + // to `parse_outer_type_alias` + Self::parse_outer_type_alias(span, parser) + } else if l.peek::() { + parser.parse::()?; + let instance = parser.parse()?; + let export_name = parser.parse()?; + let (kind, id, name) = + parser.parens(|parser| Ok((parser.parse()?, parser.parse()?, parser.parse()?)))?; + + Ok(Self { + span, + target: CoreAliasTarget::Export { + instance, + name: export_name, + kind, + }, + id, + name, + }) + } else { + Err(l.error()) + } + } +} + +/// The target of a core alias. +#[derive(Debug)] +pub enum CoreAliasTarget<'a> { + /// The alias is to an export of a core module instance. + Export { + /// The core module index exporting the item. + instance: Index<'a>, + /// The name of the exported item being aliased. + name: &'a str, + /// The export kind of the alias. + kind: ExportKind, + }, + /// The alias is to an item from an outer scope. + Outer { + /// The number of enclosing scopes to skip. + outer: Index<'a>, + /// The index of the item being aliased. + index: Index<'a>, + /// The outer alias kind. + kind: CoreOuterAliasKind, + }, +} + +/// Represents the kind of core outer alias. +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum CoreOuterAliasKind { + /// The alias is to an outer type. + Type, +} + +impl<'a> Parse<'a> for CoreOuterAliasKind { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + Ok(Self::Type) + } +} + +/// An alias to a component item. +#[derive(Debug)] +pub struct Alias<'a> { + /// Where this `alias` was defined. + pub span: Span, + /// An identifier that this alias is resolved with (optionally) for name + /// resolution. + pub id: Option>, + /// An optional name for this alias stored in the custom `name` section. + pub name: Option>, + /// The target of this alias. + pub target: AliasTarget<'a>, +} + +impl<'a> Alias<'a> { + /// Parses only an outer type alias. + pub fn parse_outer_type_alias(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + parser.parse::()?; + let outer = parser.parse()?; + let index = parser.parse()?; + + let (kind, id, name) = parser.parens(|parser| { + let kind: ComponentOuterAliasKind = parser.parse()?; + match kind { + ComponentOuterAliasKind::CoreType | ComponentOuterAliasKind::Type => {} + _ => return Err(parser.error("expected core type or type for outer alias")), + } + + Ok((kind, parser.parse()?, parser.parse()?)) + })?; + + Ok(Self { + span, + target: AliasTarget::Outer { outer, index, kind }, + id, + name, + }) + } +} + +impl<'a> Parse<'a> for Alias<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + + let mut l = parser.lookahead1(); + + let (target, id, name) = if l.peek::() { + parser.parse::()?; + let outer = parser.parse()?; + let index = parser.parse()?; + let (kind, id, name) = + parser.parens(|parser| Ok((parser.parse()?, parser.parse()?, parser.parse()?)))?; + + (AliasTarget::Outer { outer, index, kind }, id, name) + } else if l.peek::() { + parser.parse::()?; + let instance = parser.parse()?; + let export_name = parser.parse()?; + let (kind, id, name) = + parser.parens(|parser| Ok((parser.parse()?, parser.parse()?, parser.parse()?)))?; + + ( + AliasTarget::Export { + instance, + name: export_name, + kind, + }, + id, + name, + ) + } else { + return Err(l.error()); + }; + + Ok(Self { + span, + target, + id, + name, + }) + } +} + +/// Represents the kind of instance export alias. +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum ComponentExportAliasKind { + /// The alias is to a core module export. + CoreModule, + /// The alias is to a function export. + Func, + /// The alias is to a value export. + Value, + /// The alias is to a type export. + Type, + /// The alias is to a component export. + Component, + /// The alias is to an instance export. + Instance, +} + +impl<'a> Parse<'a> for ComponentExportAliasKind { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + Ok(Self::CoreModule) + } else { + Err(l.error()) + } + } else if l.peek::() { + parser.parse::()?; + Ok(Self::Func) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::Value) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::Type) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::Component) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::Instance) + } else { + Err(l.error()) + } + } +} + +/// Represents the kind of outer alias. +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum ComponentOuterAliasKind { + /// The alias is to an outer core module. + CoreModule, + /// The alias is to an outer core type. + CoreType, + /// The alias is to an outer type. + Type, + /// The alias is to an outer component. + Component, +} + +impl<'a> Parse<'a> for ComponentOuterAliasKind { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + Ok(Self::CoreModule) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::CoreType) + } else { + Err(l.error()) + } + } else if l.peek::() { + parser.parse::()?; + Ok(Self::Type) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::Component) + } else { + Err(l.error()) + } + } +} + +/// The target of a component alias. +#[derive(Debug)] +pub enum AliasTarget<'a> { + /// The alias is to an export of a component instance. + Export { + /// The component instance exporting the item. + instance: Index<'a>, + /// The name of the exported item to alias. + name: &'a str, + /// The export kind of the alias. + kind: ComponentExportAliasKind, + }, + /// The alias is to an item from an outer component. + Outer { + /// The number of enclosing components to skip. + outer: Index<'a>, + /// The index of the item being aliased. + index: Index<'a>, + /// The outer alias kind. + kind: ComponentOuterAliasKind, + }, +} diff --git a/crates/wastlhw/src/component/binary.rs b/crates/wastlhw/src/component/binary.rs new file mode 100644 index 000000000..668b75068 --- /dev/null +++ b/crates/wastlhw/src/component/binary.rs @@ -0,0 +1,842 @@ +use crate::component::*; +use crate::core; +use crate::token::{Id, Index, NameAnnotation}; +use wasm_encoder::{ + AliasSection, CanonicalFunctionSection, ComponentAliasSection, ComponentDefinedTypeEncoder, + ComponentExportSection, ComponentImportSection, ComponentInstanceSection, ComponentSection, + ComponentSectionId, ComponentStartSection, ComponentTypeEncoder, ComponentTypeSection, + CoreTypeEncoder, CoreTypeSection, InstanceSection, NestedComponentSection, RawSection, + SectionId, +}; + +pub fn encode(component: &Component<'_>) -> Vec { + match &component.kind { + ComponentKind::Text(fields) => { + encode_fields(&component.id, &component.name, fields).finish() + } + ComponentKind::Binary(bytes) => bytes.iter().flat_map(|b| b.iter().copied()).collect(), + } +} + +fn encode_fields( + // TODO: use the id and name for a future names section + _component_id: &Option>, + _component_name: &Option>, + fields: &[ComponentField<'_>], +) -> wasm_encoder::Component { + let mut e = Encoder::default(); + + for field in fields { + match field { + ComponentField::CoreModule(m) => e.encode_core_module(m), + ComponentField::CoreInstance(i) => e.encode_core_instance(i), + ComponentField::CoreAlias(a) => e.encode_core_alias(a), + ComponentField::CoreType(t) => e.encode_core_type(t), + ComponentField::Component(c) => e.encode_component(c), + ComponentField::Instance(i) => e.encode_instance(i), + ComponentField::Alias(a) => e.encode_alias(a), + ComponentField::Type(t) => e.encode_type(t), + ComponentField::CanonicalFunc(f) => e.encode_canonical_func(f), + ComponentField::CoreFunc(_) | ComponentField::Func(_) => { + unreachable!("should be expanded already") + } + ComponentField::Start(s) => e.encode_start(s), + ComponentField::Import(i) => e.encode_import(i), + ComponentField::Export(ex) => e.encode_export(ex), + ComponentField::Custom(c) => e.encode_custom(c), + } + } + + // FIXME(WebAssembly/component-model#14): once a name section is defined it + // should be encoded here. + + e.flush(None); + + e.component +} + +fn encode_core_type(encoder: CoreTypeEncoder, ty: &CoreTypeDef) { + match ty { + CoreTypeDef::Def(core::TypeDef::Func(f)) => { + encoder.function( + f.params.iter().map(|(_, _, ty)| (*ty).into()), + f.results.iter().copied().map(Into::into), + ); + } + CoreTypeDef::Def(core::TypeDef::Struct(_)) | CoreTypeDef::Def(core::TypeDef::Array(_)) => { + todo!("encoding of GC proposal types not yet implemented") + } + CoreTypeDef::Module(t) => { + encoder.module(&t.into()); + } + } +} + +fn encode_type(encoder: ComponentTypeEncoder, ty: &TypeDef) { + match ty { + TypeDef::Defined(t) => { + encode_defined_type(encoder.defined_type(), t); + } + TypeDef::Func(f) => { + let mut encoder = encoder.function(); + if f.params.len() == 1 && f.params[0].name.is_none() { + encoder.param(&f.params[0].ty); + } else { + encoder.params(f.params.iter().map(|p| (p.name.unwrap_or(""), &p.ty))); + } + + if f.results.len() == 1 && f.results[0].name.is_none() { + encoder.result(&f.results[0].ty); + } else { + encoder.results(f.results.iter().map(|r| (r.name.unwrap_or(""), &r.ty))); + } + } + TypeDef::Component(c) => { + encoder.component(&c.into()); + } + TypeDef::Instance(i) => { + encoder.instance(&i.into()); + } + } +} + +fn encode_defined_type(encoder: ComponentDefinedTypeEncoder, ty: &ComponentDefinedType) { + match ty { + ComponentDefinedType::Primitive(p) => encoder.primitive((*p).into()), + ComponentDefinedType::Record(r) => { + encoder.record(r.fields.iter().map(|f| (f.name, &f.ty))); + } + ComponentDefinedType::Variant(v) => { + encoder.variant(v.cases.iter().map(|c| { + ( + c.name, + c.ty.as_ref().map(Into::into), + c.refines.as_ref().map(Into::into), + ) + })); + } + ComponentDefinedType::List(l) => { + encoder.list(l.element.as_ref()); + } + ComponentDefinedType::Tuple(t) => { + encoder.tuple(t.fields.iter()); + } + ComponentDefinedType::Flags(f) => { + encoder.flags(f.names.iter().copied()); + } + ComponentDefinedType::Enum(e) => { + encoder.enum_type(e.names.iter().copied()); + } + ComponentDefinedType::Union(u) => encoder.union(u.types.iter()), + ComponentDefinedType::Option(o) => { + encoder.option(o.element.as_ref()); + } + ComponentDefinedType::Result(e) => { + encoder.result( + e.ok.as_deref().map(Into::into), + e.err.as_deref().map(Into::into), + ); + } + } +} + +#[derive(Default)] +struct Encoder { + component: wasm_encoder::Component, + current_section_id: Option, + + // Core sections + // Note: module sections are written immediately + core_instances: InstanceSection, + core_aliases: AliasSection, + core_types: CoreTypeSection, + + // Component sections + // Note: custom, component, start sections are written immediately + instances: ComponentInstanceSection, + aliases: ComponentAliasSection, + types: ComponentTypeSection, + funcs: CanonicalFunctionSection, + imports: ComponentImportSection, + exports: ComponentExportSection, +} + +impl Encoder { + fn encode_custom(&mut self, custom: &Custom) { + // Flush any in-progress section before encoding the customs section + self.flush(None); + self.component.section(custom); + } + + fn encode_core_module(&mut self, module: &CoreModule) { + // Flush any in-progress section before encoding the module + self.flush(None); + + match &module.kind { + CoreModuleKind::Import { .. } => unreachable!("should be expanded already"), + CoreModuleKind::Inline { fields } => { + // TODO: replace this with a wasm-encoder based encoding (should return `wasm_encoder::Module`) + let data = crate::core::binary::encode(&module.id, &module.name, fields); + self.component.section(&RawSection { + id: ComponentSectionId::CoreModule.into(), + data: &data, + }); + } + } + } + + fn encode_core_instance(&mut self, instance: &CoreInstance) { + match &instance.kind { + CoreInstanceKind::Instantiate { module, args } => { + self.core_instances.instantiate( + module.into(), + args.iter().map(|arg| (arg.name, (&arg.kind).into())), + ); + } + CoreInstanceKind::BundleOfExports(exports) => { + self.core_instances.export_items(exports.iter().map(|e| { + let (kind, index) = (&e.item).into(); + (e.name, kind, index) + })); + } + } + + self.flush(Some(self.core_instances.id())); + } + + fn encode_core_alias(&mut self, alias: &CoreAlias) { + match &alias.target { + CoreAliasTarget::Export { + instance, + name, + kind, + } => { + self.core_aliases + .instance_export((*instance).into(), (*kind).into(), name); + } + CoreAliasTarget::Outer { outer, index, kind } => { + self.core_aliases + .outer((*outer).into(), (*kind).into(), (*index).into()); + } + } + + self.flush(Some(self.core_aliases.id())); + } + + fn encode_core_type(&mut self, ty: &CoreType) { + encode_core_type(self.core_types.ty(), &ty.def); + self.flush(Some(self.core_types.id())); + } + + fn encode_component(&mut self, component: &NestedComponent) { + // Flush any in-progress section before encoding the component + self.flush(None); + + match &component.kind { + NestedComponentKind::Import { .. } => unreachable!("should be expanded already"), + NestedComponentKind::Inline(fields) => { + self.component + .section(&NestedComponentSection(&encode_fields( + &component.id, + &component.name, + fields, + ))); + } + } + } + + fn encode_instance(&mut self, instance: &Instance) { + match &instance.kind { + InstanceKind::Import { .. } => unreachable!("should be expanded already"), + InstanceKind::Instantiate { component, args } => { + self.instances.instantiate( + component.into(), + args.iter().map(|arg| { + let (kind, index) = (&arg.kind).into(); + (arg.name, kind, index) + }), + ); + } + InstanceKind::BundleOfExports(exports) => { + self.instances.export_items(exports.iter().map(|e| { + let (kind, index) = (&e.kind).into(); + (e.name, kind, index) + })); + } + } + + self.flush(Some(self.instances.id())); + } + + fn encode_alias(&mut self, alias: &Alias) { + match &alias.target { + AliasTarget::Export { + instance, + name, + kind, + } => { + self.aliases + .instance_export((*instance).into(), (*kind).into(), name); + } + AliasTarget::Outer { outer, index, kind } => { + self.aliases + .outer((*outer).into(), (*kind).into(), (*index).into()); + } + } + + self.flush(Some(self.aliases.id())); + } + + fn encode_start(&mut self, start: &Start) { + // Flush any in-progress section before encoding the start section + self.flush(None); + + self.component.section(&ComponentStartSection { + function_index: start.func.into(), + args: start.args.iter().map(|a| a.idx.into()).collect::>(), + }); + } + + fn encode_type(&mut self, ty: &Type) { + encode_type(self.types.ty(), &ty.def); + self.flush(Some(self.types.id())); + } + + fn encode_canonical_func(&mut self, func: &CanonicalFunc) { + match &func.kind { + CanonicalFuncKind::Lift { ty, info } => { + self.funcs.lift( + info.func.idx.into(), + ty.into(), + info.opts.iter().map(Into::into), + ); + } + CanonicalFuncKind::Lower(info) => { + self.funcs + .lower(info.func.idx.into(), info.opts.iter().map(Into::into)); + } + } + + self.flush(Some(self.funcs.id())); + } + + fn encode_import(&mut self, import: &ComponentImport) { + self.imports.import(import.name, (&import.item.kind).into()); + self.flush(Some(self.imports.id())); + } + + fn encode_export(&mut self, export: &ComponentExport) { + let (kind, index) = (&export.kind).into(); + self.exports.export(export.name, kind, index); + self.flush(Some(self.exports.id())); + } + + fn flush(&mut self, section_id: Option) { + if self.current_section_id == section_id { + return; + } + + if let Some(id) = self.current_section_id { + match id { + // 0 => custom sections are written immediately + // 1 => core modules sections are written immediately + 2 => { + assert_eq!(id, self.core_instances.id()); + self.component.section(&self.core_instances); + self.core_instances = Default::default(); + } + 3 => { + assert_eq!(id, self.core_aliases.id()); + self.component.section(&self.core_aliases); + self.core_aliases = Default::default(); + } + 4 => { + assert_eq!(id, self.core_types.id()); + self.component.section(&self.core_types); + self.core_types = Default::default(); + } + // 5 => components sections are written immediately + 6 => { + assert_eq!(id, self.instances.id()); + self.component.section(&self.instances); + self.instances = Default::default(); + } + 7 => { + assert_eq!(id, self.aliases.id()); + self.component.section(&self.aliases); + self.aliases = Default::default(); + } + 8 => { + assert_eq!(id, self.types.id()); + self.component.section(&self.types); + self.types = Default::default(); + } + 9 => { + assert_eq!(id, self.funcs.id()); + self.component.section(&self.funcs); + self.funcs = Default::default(); + } + // 10 => start sections are written immediately + 11 => { + assert_eq!(id, self.imports.id()); + self.component.section(&self.imports); + self.imports = Default::default(); + } + 12 => { + assert_eq!(id, self.exports.id()); + self.component.section(&self.exports); + self.exports = Default::default(); + } + _ => unreachable!("unknown incremental component section id: {}", id), + } + } + + self.current_section_id = section_id + } +} + +// This implementation is much like `wasm_encoder::CustomSection`, except +// that it extends via a list of slices instead of a single slice. +impl wasm_encoder::Encode for Custom<'_> { + fn encode(&self, sink: &mut Vec) { + let mut buf = [0u8; 5]; + let encoded_name_len = + leb128::write::unsigned(&mut &mut buf[..], u64::try_from(self.name.len()).unwrap()) + .unwrap(); + let data_len = self.data.iter().fold(0, |acc, s| acc + s.len()); + + // name length + (encoded_name_len + self.name.len() + data_len).encode(sink); + + // name + self.name.encode(sink); + + // data + for s in &self.data { + sink.extend(*s); + } + } +} + +impl wasm_encoder::ComponentSection for Custom<'_> { + fn id(&self) -> u8 { + SectionId::Custom.into() + } +} + +// TODO: move these core conversion functions to the core module +// once we update core encoding to use wasm-encoder. +impl From> for wasm_encoder::ValType { + fn from(ty: core::ValType) -> Self { + match ty { + core::ValType::I32 => Self::I32, + core::ValType::I64 => Self::I64, + core::ValType::F32 => Self::F32, + core::ValType::F64 => Self::F64, + core::ValType::V128 => Self::V128, + core::ValType::Ref(r) => r.into(), + } + } +} + +impl From> for wasm_encoder::ValType { + fn from(r: core::RefType<'_>) -> Self { + match r.heap { + core::HeapType::Func => Self::FuncRef, + core::HeapType::Extern => Self::ExternRef, + _ => { + todo!("encoding of GC proposal types not yet implemented") + } + } + } +} + +impl From<&core::ItemKind<'_>> for wasm_encoder::EntityType { + fn from(kind: &core::ItemKind) -> Self { + match kind { + core::ItemKind::Func(t) => Self::Function(t.into()), + core::ItemKind::Table(t) => Self::Table((*t).into()), + core::ItemKind::Memory(t) => Self::Memory((*t).into()), + core::ItemKind::Global(t) => Self::Global((*t).into()), + core::ItemKind::Tag(t) => Self::Tag(t.into()), + } + } +} + +impl From> for wasm_encoder::TableType { + fn from(ty: core::TableType) -> Self { + Self { + element_type: ty.elem.into(), + minimum: ty.limits.min, + maximum: ty.limits.max, + } + } +} + +impl From for wasm_encoder::MemoryType { + fn from(ty: core::MemoryType) -> Self { + let (minimum, maximum, memory64, shared) = match ty { + core::MemoryType::B32 { limits, shared } => { + (limits.min.into(), limits.max.map(Into::into), false, shared) + } + core::MemoryType::B64 { limits, shared } => (limits.min, limits.max, true, shared), + }; + + Self { + minimum, + maximum, + memory64, + shared, + } + } +} + +impl From> for wasm_encoder::GlobalType { + fn from(ty: core::GlobalType) -> Self { + Self { + val_type: ty.ty.into(), + mutable: ty.mutable, + } + } +} + +impl From<&core::TagType<'_>> for wasm_encoder::TagType { + fn from(ty: &core::TagType) -> Self { + match ty { + core::TagType::Exception(r) => Self { + kind: wasm_encoder::TagKind::Exception, + func_type_idx: r.into(), + }, + } + } +} + +impl From<&core::TypeUse<'_, T>> for u32 { + fn from(u: &core::TypeUse<'_, T>) -> Self { + match &u.index { + Some(i) => (*i).into(), + None => unreachable!("unresolved type use in encoding: {:?}", u), + } + } +} + +impl From<&CoreInstantiationArgKind<'_>> for wasm_encoder::ModuleArg { + fn from(kind: &CoreInstantiationArgKind) -> Self { + match kind { + CoreInstantiationArgKind::Instance(i) => { + wasm_encoder::ModuleArg::Instance(i.idx.into()) + } + CoreInstantiationArgKind::BundleOfExports(..) => { + unreachable!("should be expanded already") + } + } + } +} + +impl From<&CoreItemRef<'_, core::ExportKind>> for (wasm_encoder::ExportKind, u32) { + fn from(item: &CoreItemRef<'_, core::ExportKind>) -> Self { + match &item.kind { + core::ExportKind::Func => (wasm_encoder::ExportKind::Func, item.idx.into()), + core::ExportKind::Table => (wasm_encoder::ExportKind::Table, item.idx.into()), + core::ExportKind::Memory => (wasm_encoder::ExportKind::Memory, item.idx.into()), + core::ExportKind::Global => (wasm_encoder::ExportKind::Global, item.idx.into()), + core::ExportKind::Tag => (wasm_encoder::ExportKind::Tag, item.idx.into()), + } + } +} + +impl From for wasm_encoder::ExportKind { + fn from(kind: core::ExportKind) -> Self { + match kind { + core::ExportKind::Func => Self::Func, + core::ExportKind::Table => Self::Table, + core::ExportKind::Memory => Self::Memory, + core::ExportKind::Global => Self::Global, + core::ExportKind::Tag => Self::Tag, + } + } +} + +impl From> for u32 { + fn from(i: Index<'_>) -> Self { + match i { + Index::Num(i, _) => i, + Index::Id(_) => unreachable!("unresolved index in encoding: {:?}", i), + } + } +} + +impl From<&ItemRef<'_, T>> for u32 { + fn from(i: &ItemRef<'_, T>) -> Self { + assert!(i.export_names.is_empty()); + i.idx.into() + } +} + +impl From<&CoreTypeUse<'_, T>> for u32 { + fn from(u: &CoreTypeUse<'_, T>) -> Self { + match u { + CoreTypeUse::Inline(_) => unreachable!("should be expanded already"), + CoreTypeUse::Ref(r) => r.idx.into(), + } + } +} + +impl From<&ComponentTypeUse<'_, T>> for u32 { + fn from(u: &ComponentTypeUse<'_, T>) -> Self { + match u { + ComponentTypeUse::Inline(_) => unreachable!("should be expanded already"), + ComponentTypeUse::Ref(r) => r.idx.into(), + } + } +} + +impl From<&ComponentValType<'_>> for wasm_encoder::ComponentValType { + fn from(r: &ComponentValType) -> Self { + match r { + ComponentValType::Inline(ComponentDefinedType::Primitive(p)) => { + Self::Primitive((*p).into()) + } + ComponentValType::Ref(i) => Self::Type(u32::from(*i)), + ComponentValType::Inline(_) => unreachable!("should be expanded by now"), + } + } +} + +impl From for wasm_encoder::PrimitiveValType { + fn from(p: PrimitiveValType) -> Self { + match p { + PrimitiveValType::Bool => Self::Bool, + PrimitiveValType::S8 => Self::S8, + PrimitiveValType::U8 => Self::U8, + PrimitiveValType::S16 => Self::S16, + PrimitiveValType::U16 => Self::U16, + PrimitiveValType::S32 => Self::S32, + PrimitiveValType::U32 => Self::U32, + PrimitiveValType::S64 => Self::S64, + PrimitiveValType::U64 => Self::U64, + PrimitiveValType::Float32 => Self::Float32, + PrimitiveValType::Float64 => Self::Float64, + PrimitiveValType::Char => Self::Char, + PrimitiveValType::String => Self::String, + } + } +} + +impl From<&Refinement<'_>> for u32 { + fn from(r: &Refinement) -> Self { + match r { + Refinement::Index(..) => unreachable!("should be resolved by now"), + Refinement::Resolved(i) => *i, + } + } +} + +impl From<&ItemSigKind<'_>> for wasm_encoder::ComponentTypeRef { + fn from(k: &ItemSigKind) -> Self { + match k { + ItemSigKind::Component(c) => Self::Component(c.into()), + ItemSigKind::CoreModule(m) => Self::Module(m.into()), + ItemSigKind::Instance(i) => Self::Instance(i.into()), + ItemSigKind::Value(v) => Self::Value((&v.0).into()), + ItemSigKind::Func(f) => Self::Func(f.into()), + ItemSigKind::Type(TypeBounds::Eq(t)) => { + Self::Type(wasm_encoder::TypeBounds::Eq, (*t).into()) + } + } + } +} + +impl From<&ComponentType<'_>> for wasm_encoder::ComponentType { + fn from(ty: &ComponentType) -> Self { + let mut encoded = wasm_encoder::ComponentType::new(); + + for decl in &ty.decls { + match decl { + ComponentTypeDecl::CoreType(t) => { + encode_core_type(encoded.core_type(), &t.def); + } + ComponentTypeDecl::Type(t) => { + encode_type(encoded.ty(), &t.def); + } + ComponentTypeDecl::Alias(a) => match &a.target { + AliasTarget::Outer { + outer, + index, + kind: ComponentOuterAliasKind::CoreType, + } => { + encoded.alias_outer_core_type(u32::from(*outer), u32::from(*index)); + } + AliasTarget::Outer { + outer, + index, + kind: ComponentOuterAliasKind::Type, + } => { + encoded.alias_outer_type(u32::from(*outer), u32::from(*index)); + } + _ => unreachable!("only outer type aliases are supported"), + }, + ComponentTypeDecl::Import(i) => { + encoded.import(i.name, (&i.item.kind).into()); + } + ComponentTypeDecl::Export(e) => { + encoded.export(e.name, (&e.item.kind).into()); + } + } + } + + encoded + } +} + +impl From<&InstanceType<'_>> for wasm_encoder::InstanceType { + fn from(ty: &InstanceType) -> Self { + let mut encoded = wasm_encoder::InstanceType::new(); + + for decl in &ty.decls { + match decl { + InstanceTypeDecl::CoreType(t) => { + encode_core_type(encoded.core_type(), &t.def); + } + InstanceTypeDecl::Type(t) => { + encode_type(encoded.ty(), &t.def); + } + InstanceTypeDecl::Alias(a) => match &a.target { + AliasTarget::Outer { + outer, + index, + kind: ComponentOuterAliasKind::CoreType, + } => { + encoded.alias_outer_core_type(u32::from(*outer), u32::from(*index)); + } + AliasTarget::Outer { + outer, + index, + kind: ComponentOuterAliasKind::Type, + } => { + encoded.alias_outer_type(u32::from(*outer), u32::from(*index)); + } + _ => unreachable!("only outer type aliases are supported"), + }, + InstanceTypeDecl::Export(e) => { + encoded.export(e.name, (&e.item.kind).into()); + } + } + } + + encoded + } +} + +impl From<&ModuleType<'_>> for wasm_encoder::ModuleType { + fn from(ty: &ModuleType) -> Self { + let mut encoded = wasm_encoder::ModuleType::new(); + + for decl in &ty.decls { + match decl { + ModuleTypeDecl::Type(t) => match &t.def { + core::TypeDef::Func(f) => encoded.ty().function( + f.params.iter().map(|(_, _, ty)| (*ty).into()), + f.results.iter().copied().map(Into::into), + ), + core::TypeDef::Struct(_) | core::TypeDef::Array(_) => { + todo!("encoding of GC proposal types not yet implemented") + } + }, + ModuleTypeDecl::Alias(a) => match &a.target { + CoreAliasTarget::Outer { + outer, + index, + kind: CoreOuterAliasKind::Type, + } => { + encoded.alias_outer_core_type(u32::from(*outer), u32::from(*index)); + } + _ => unreachable!("only outer type aliases are supported"), + }, + ModuleTypeDecl::Import(i) => { + encoded.import(i.module, i.field, (&i.item.kind).into()); + } + ModuleTypeDecl::Export(name, item) => { + encoded.export(name, (&item.kind).into()); + } + } + } + + encoded + } +} + +impl From<&InstantiationArgKind<'_>> for (wasm_encoder::ComponentExportKind, u32) { + fn from(kind: &InstantiationArgKind) -> Self { + match kind { + InstantiationArgKind::Item(i) => i.into(), + InstantiationArgKind::BundleOfExports(..) => unreachable!("should be expanded already"), + } + } +} + +impl From<&ComponentExportKind<'_>> for (wasm_encoder::ComponentExportKind, u32) { + fn from(kind: &ComponentExportKind) -> Self { + match kind { + ComponentExportKind::CoreModule(m) => { + (wasm_encoder::ComponentExportKind::Module, m.idx.into()) + } + ComponentExportKind::Func(f) => (wasm_encoder::ComponentExportKind::Func, f.idx.into()), + ComponentExportKind::Value(v) => { + (wasm_encoder::ComponentExportKind::Value, v.idx.into()) + } + ComponentExportKind::Type(t) => (wasm_encoder::ComponentExportKind::Type, t.idx.into()), + ComponentExportKind::Component(c) => { + (wasm_encoder::ComponentExportKind::Component, c.idx.into()) + } + ComponentExportKind::Instance(i) => { + (wasm_encoder::ComponentExportKind::Instance, i.idx.into()) + } + } + } +} + +impl From for wasm_encoder::CoreOuterAliasKind { + fn from(kind: CoreOuterAliasKind) -> Self { + match kind { + CoreOuterAliasKind::Type => Self::Type, + } + } +} + +impl From for wasm_encoder::ComponentOuterAliasKind { + fn from(kind: ComponentOuterAliasKind) -> Self { + match kind { + ComponentOuterAliasKind::CoreModule => Self::CoreModule, + ComponentOuterAliasKind::CoreType => Self::CoreType, + ComponentOuterAliasKind::Type => Self::Type, + ComponentOuterAliasKind::Component => Self::Component, + } + } +} + +impl From for wasm_encoder::ComponentExportKind { + fn from(kind: ComponentExportAliasKind) -> Self { + match kind { + ComponentExportAliasKind::CoreModule => Self::Module, + ComponentExportAliasKind::Func => Self::Func, + ComponentExportAliasKind::Value => Self::Value, + ComponentExportAliasKind::Type => Self::Type, + ComponentExportAliasKind::Component => Self::Component, + ComponentExportAliasKind::Instance => Self::Instance, + } + } +} + +impl From<&CanonOpt<'_>> for wasm_encoder::CanonicalOption { + fn from(opt: &CanonOpt) -> Self { + match opt { + CanonOpt::StringUtf8 => Self::UTF8, + CanonOpt::StringUtf16 => Self::UTF16, + CanonOpt::StringLatin1Utf16 => Self::CompactUTF16, + CanonOpt::Memory(m) => Self::Memory(m.idx.into()), + CanonOpt::Realloc(f) => Self::Realloc(f.idx.into()), + CanonOpt::PostReturn(f) => Self::PostReturn(f.idx.into()), + } + } +} diff --git a/crates/wastlhw/src/component/component.rs b/crates/wastlhw/src/component/component.rs new file mode 100644 index 000000000..3f319507a --- /dev/null +++ b/crates/wastlhw/src/component/component.rs @@ -0,0 +1,318 @@ +use crate::annotation; +use crate::component::*; +use crate::core; +use crate::kw; +use crate::parser::{Parse, Parser, Result}; +use crate::token::Index; +use crate::token::{Id, NameAnnotation, Span}; + +/// A parsed WebAssembly component module. +#[derive(Debug)] +pub struct Component<'a> { + /// Where this `component` was defined + pub span: Span, + /// An optional identifier this component is known by + pub id: Option>, + /// An optional `@name` annotation for this component + pub name: Option>, + /// What kind of component this was parsed as. + pub kind: ComponentKind<'a>, +} + +/// The different kinds of ways to define a component. +#[derive(Debug)] +pub enum ComponentKind<'a> { + /// A component defined in the textual s-expression format. + Text(Vec>), + /// A component that had its raw binary bytes defined via the `binary` + /// directive. + Binary(Vec<&'a [u8]>), +} + +impl<'a> Component<'a> { + /// Performs a name resolution pass on this [`Component`], resolving all + /// symbolic names to indices. + /// + /// The WAT format contains a number of shorthands to make it easier to + /// write, such as inline exports, inline imports, inline type definitions, + /// etc. Additionally it allows using symbolic names such as `$foo` instead + /// of using indices. This module will postprocess an AST to remove all of + /// this syntactic sugar, preparing the AST for binary emission. This is + /// where expansion and name resolution happens. + /// + /// This function will mutate the AST of this [`Component`] and replace all + /// [`Index`](crate::token::Index) arguments with `Index::Num`. This will + /// also expand inline exports/imports listed on fields and handle various + /// other shorthands of the text format. + /// + /// If successful the AST was modified to be ready for binary encoding. + /// + /// # Errors + /// + /// If an error happens during resolution, such a name resolution error or + /// items are found in the wrong order, then an error is returned. + pub fn resolve(&mut self) -> std::result::Result<(), crate::Error> { + match &mut self.kind { + ComponentKind::Text(fields) => { + crate::component::expand::expand(fields); + } + ComponentKind::Binary(_) => {} + } + crate::component::resolve::resolve(self) + } + + /// Encodes this [`Component`] to its binary form. + /// + /// This function will take the textual representation in [`Component`] and + /// perform all steps necessary to convert it to a binary WebAssembly + /// component, suitable for writing to a `*.wasm` file. This function may + /// internally modify the [`Component`], for example: + /// + /// * Name resolution is performed to ensure that `Index::Id` isn't present + /// anywhere in the AST. + /// + /// * Inline shorthands such as imports/exports/types are all expanded to be + /// dedicated fields of the component. + /// + /// * Component fields may be shuffled around to preserve index ordering from + /// expansions. + /// + /// After all of this expansion has happened the component will be converted to + /// its binary form and returned as a `Vec`. This is then suitable to + /// hand off to other wasm runtimes and such. + /// + /// # Errors + /// + /// This function can return an error for name resolution errors and other + /// expansion-related errors. + pub fn encode(&mut self) -> std::result::Result, crate::Error> { + self.resolve()?; + Ok(crate::component::binary::encode(self)) + } + + pub(crate) fn validate(&self, parser: Parser<'_>) -> Result<()> { + let mut starts = 0; + if let ComponentKind::Text(fields) = &self.kind { + for item in fields.iter() { + if let ComponentField::Start(_) = item { + starts += 1; + } + } + } + if starts > 1 { + return Err(parser.error("multiple start sections found")); + } + Ok(()) + } +} + +impl<'a> Parse<'a> for Component<'a> { + fn parse(parser: Parser<'a>) -> Result { + let _r = parser.register_annotation("custom"); + + let span = parser.parse::()?.0; + let id = parser.parse()?; + let name = parser.parse()?; + + let kind = if parser.peek::() { + parser.parse::()?; + let mut data = Vec::new(); + while !parser.is_empty() { + data.push(parser.parse()?); + } + ComponentKind::Binary(data) + } else { + ComponentKind::Text(ComponentField::parse_remaining(parser)?) + }; + Ok(Component { + span, + id, + name, + kind, + }) + } +} + +/// A listing of all possible fields that can make up a WebAssembly component. +#[allow(missing_docs)] +#[derive(Debug)] +pub enum ComponentField<'a> { + CoreModule(CoreModule<'a>), + CoreInstance(CoreInstance<'a>), + CoreAlias(CoreAlias<'a>), + CoreType(CoreType<'a>), + Component(NestedComponent<'a>), + Instance(Instance<'a>), + Alias(Alias<'a>), + Type(Type<'a>), + CanonicalFunc(CanonicalFunc<'a>), + CoreFunc(CoreFunc<'a>), // Supports inverted forms of other items + Func(Func<'a>), // Supports inverted forms of other items + Start(Start<'a>), + Import(ComponentImport<'a>), + Export(ComponentExport<'a>), + Custom(Custom<'a>), +} + +impl<'a> ComponentField<'a> { + fn parse_remaining(parser: Parser<'a>) -> Result> { + let mut fields = Vec::new(); + while !parser.is_empty() { + fields.push(parser.parens(ComponentField::parse)?); + } + Ok(fields) + } +} + +impl<'a> Parse<'a> for ComponentField<'a> { + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::() { + if parser.peek2::() { + return Ok(Self::CoreModule(parser.parse()?)); + } + if parser.peek2::() { + return Ok(Self::CoreInstance(parser.parse()?)); + } + if parser.peek2::() { + return Ok(Self::CoreAlias(parser.parse()?)); + } + if parser.peek2::() { + return Ok(Self::CoreType(parser.parse()?)); + } + if parser.peek2::() { + return Ok(Self::CoreFunc(parser.parse()?)); + } + } else { + if parser.peek::() { + return Ok(Self::Component(parser.parse()?)); + } + if parser.peek::() { + return Ok(Self::Instance(parser.parse()?)); + } + if parser.peek::() { + return Ok(Self::Alias(parser.parse()?)); + } + if parser.peek::() { + return Ok(Self::Type(parser.parse()?)); + } + if parser.peek::() { + return Ok(Self::Import(parser.parse()?)); + } + if parser.peek::() { + return Ok(Self::Func(parser.parse()?)); + } + if parser.peek::() { + return Ok(Self::Export(parser.parse()?)); + } + if parser.peek::() { + return Ok(Self::Start(parser.parse()?)); + } + if parser.peek::() { + return Ok(Self::Custom(parser.parse()?)); + } + } + Err(parser.error("expected valid component field")) + } +} + +/// A function to call at instantiation time. +#[derive(Debug)] +pub struct Start<'a> { + /// The function to call. + pub func: Index<'a>, + /// The arguments to pass to the function. + pub args: Vec>, + /// Name of the result value. + pub result: Option>, +} + +impl<'a> Parse<'a> for Start<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + let func = parser.parse()?; + let mut args = Vec::new(); + while !parser.is_empty() && !parser.peek2::() { + args.push(parser.parens(|parser| parser.parse())?); + } + let result = if !parser.is_empty() { + parser.parens(|parser| { + parser.parse::()?; + if !parser.is_empty() { + parser.parens(|parser| { + parser.parse::()?; + let id = parser.parse()?; + Ok(Some(id)) + }) + } else { + Ok(None) + } + })? + } else { + None + }; + Ok(Start { func, args, result }) + } +} + +/// A nested WebAssembly component. +#[derive(Debug)] +pub struct NestedComponent<'a> { + /// Where this `component` was defined + pub span: Span, + /// An optional identifier this component is known by + pub id: Option>, + /// An optional `@name` annotation for this component + pub name: Option>, + /// If present, inline export annotations which indicate names this + /// definition should be exported under. + pub exports: core::InlineExport<'a>, + /// What kind of component this was parsed as. + pub kind: NestedComponentKind<'a>, +} + +/// The different kinds of ways to define a nested component. +#[derive(Debug)] +pub enum NestedComponentKind<'a> { + /// This is actually an inline import of a component + Import { + /// The information about where this is being imported from. + import: InlineImport<'a>, + /// The type of component being imported. + ty: ComponentTypeUse<'a, ComponentType<'a>>, + }, + /// The component is defined inline as a local definition with its fields + /// listed here. + Inline(Vec>), +} + +impl<'a> Parse<'a> for NestedComponent<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.depth_check()?; + + let span = parser.parse::()?.0; + let id = parser.parse()?; + let name = parser.parse()?; + let exports = parser.parse()?; + + let kind = if let Some(import) = parser.parse()? { + NestedComponentKind::Import { + import, + ty: parser.parse()?, + } + } else { + let mut fields = Vec::new(); + while !parser.is_empty() { + fields.push(parser.parens(|p| p.parse())?); + } + NestedComponentKind::Inline(fields) + }; + + Ok(NestedComponent { + span, + id, + name, + exports, + kind, + }) + } +} diff --git a/crates/wastlhw/src/component/custom.rs b/crates/wastlhw/src/component/custom.rs new file mode 100644 index 000000000..b17a7fafb --- /dev/null +++ b/crates/wastlhw/src/component/custom.rs @@ -0,0 +1,28 @@ +use crate::annotation; +use crate::parser::{Parse, Parser, Result}; +use crate::token::Span; + +/// A custom section within a component. +#[derive(Debug)] +pub struct Custom<'a> { + /// Where this `@custom` was defined. + pub span: Span, + + /// Name of the custom section. + pub name: &'a str, + + /// Payload of this custom section. + pub data: Vec<&'a [u8]>, +} + +impl<'a> Parse<'a> for Custom<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let name = parser.parse()?; + let mut data = Vec::new(); + while !parser.is_empty() { + data.push(parser.parse()?); + } + Ok(Self { span, name, data }) + } +} diff --git a/crates/wastlhw/src/component/expand.rs b/crates/wastlhw/src/component/expand.rs new file mode 100644 index 000000000..5293fde11 --- /dev/null +++ b/crates/wastlhw/src/component/expand.rs @@ -0,0 +1,825 @@ +use crate::component::*; +use crate::core; +use crate::gensym; +use crate::kw; +use crate::token::Id; +use crate::token::{Index, Span}; +use std::collections::HashMap; +use std::mem; + +/// Performs an AST "expansion" pass over the component fields provided. +/// +/// This expansion is intended to desugar the AST from various parsed constructs +/// to bits and bobs amenable for name resolution as well as binary encoding. +/// For example `(import "" (func))` is split into a type definition followed by +/// the import referencing that type definition. +/// +/// Most forms of AST expansion happen in this file and afterwards the AST will +/// be handed to the name resolution pass which will convert `Index::Id` to +/// `Index::Num` wherever it's found. +pub fn expand(fields: &mut Vec>) { + Expander::default().expand_component_fields(fields) +} + +enum AnyType<'a> { + Core(CoreType<'a>), + Component(Type<'a>), +} + +impl<'a> From> for ComponentTypeDecl<'a> { + fn from(t: AnyType<'a>) -> Self { + match t { + AnyType::Core(t) => Self::CoreType(t), + AnyType::Component(t) => Self::Type(t), + } + } +} + +impl<'a> From> for InstanceTypeDecl<'a> { + fn from(t: AnyType<'a>) -> Self { + match t { + AnyType::Core(t) => Self::CoreType(t), + AnyType::Component(t) => Self::Type(t), + } + } +} + +impl<'a> From> for ComponentField<'a> { + fn from(t: AnyType<'a>) -> Self { + match t { + AnyType::Core(t) => Self::CoreType(t), + AnyType::Component(t) => Self::Type(t), + } + } +} + +#[derive(Default)] +struct Expander<'a> { + /// Fields, during processing, which should be prepended to the + /// currently-being-processed field. This should always be empty after + /// processing is complete. + types_to_prepend: Vec>, + component_fields_to_prepend: Vec>, + + /// Fields that are appended to the end of the module once everything has + /// finished. + component_fields_to_append: Vec>, +} + +impl<'a> Expander<'a> { + fn expand_component_fields(&mut self, fields: &mut Vec>) { + let mut cur = 0; + while cur < fields.len() { + self.expand_field(&mut fields[cur]); + let amt = self.types_to_prepend.len() + self.component_fields_to_prepend.len(); + fields.splice(cur..cur, self.component_fields_to_prepend.drain(..)); + fields.splice(cur..cur, self.types_to_prepend.drain(..).map(Into::into)); + cur += 1 + amt; + } + fields.append(&mut self.component_fields_to_append); + } + + fn expand_decls(&mut self, decls: &mut Vec, expand: fn(&mut Self, &mut T)) + where + T: From>, + { + let mut cur = 0; + while cur < decls.len() { + expand(self, &mut decls[cur]); + assert!(self.component_fields_to_prepend.is_empty()); + assert!(self.component_fields_to_append.is_empty()); + let amt = self.types_to_prepend.len(); + decls.splice(cur..cur, self.types_to_prepend.drain(..).map(From::from)); + cur += 1 + amt; + } + } + + fn expand_field(&mut self, item: &mut ComponentField<'a>) { + let expanded = match item { + ComponentField::CoreModule(m) => self.expand_core_module(m), + ComponentField::CoreInstance(i) => { + self.expand_core_instance(i); + None + } + ComponentField::CoreType(t) => { + self.expand_core_type(t); + None + } + ComponentField::Component(c) => self.expand_nested_component(c), + ComponentField::Instance(i) => self.expand_instance(i), + ComponentField::Type(t) => { + self.expand_type(t); + None + } + ComponentField::CanonicalFunc(f) => { + self.expand_canonical_func(f); + None + } + ComponentField::CoreFunc(f) => self.expand_core_func(f), + ComponentField::Func(f) => self.expand_func(f), + ComponentField::Import(i) => { + self.expand_item_sig(&mut i.item); + None + } + ComponentField::Start(_) + | ComponentField::CoreAlias(_) + | ComponentField::Alias(_) + | ComponentField::Export(_) + | ComponentField::Custom(_) => None, + }; + + if let Some(expanded) = expanded { + *item = expanded; + } + } + + fn expand_core_module(&mut self, module: &mut CoreModule<'a>) -> Option> { + for name in module.exports.names.drain(..) { + let id = gensym::fill(module.span, &mut module.id); + self.component_fields_to_append + .push(ComponentField::Export(ComponentExport { + span: module.span, + name, + kind: ComponentExportKind::module(module.span, id), + })); + } + match &mut module.kind { + // inline modules are expanded later during resolution + CoreModuleKind::Inline { .. } => None, + CoreModuleKind::Import { import, ty } => { + let idx = self.expand_core_type_use(ty); + Some(ComponentField::Import(ComponentImport { + span: module.span, + name: import.name, + item: ItemSig { + span: module.span, + id: module.id, + name: None, + kind: ItemSigKind::CoreModule(CoreTypeUse::Ref(idx)), + }, + })) + } + } + } + + fn expand_core_instance(&mut self, instance: &mut CoreInstance<'a>) { + match &mut instance.kind { + CoreInstanceKind::Instantiate { args, .. } => { + for arg in args { + self.expand_core_instantiation_arg(&mut arg.kind); + } + } + CoreInstanceKind::BundleOfExports { .. } => {} + } + } + + fn expand_nested_component( + &mut self, + component: &mut NestedComponent<'a>, + ) -> Option> { + for name in component.exports.names.drain(..) { + let id = gensym::fill(component.span, &mut component.id); + self.component_fields_to_append + .push(ComponentField::Export(ComponentExport { + span: component.span, + name, + kind: ComponentExportKind::component(component.span, id), + })); + } + match &mut component.kind { + NestedComponentKind::Inline(fields) => { + expand(fields); + None + } + NestedComponentKind::Import { import, ty } => { + let idx = self.expand_component_type_use(ty); + Some(ComponentField::Import(ComponentImport { + span: component.span, + name: import.name, + item: ItemSig { + span: component.span, + id: component.id, + name: None, + kind: ItemSigKind::Component(ComponentTypeUse::Ref(idx)), + }, + })) + } + } + } + + fn expand_instance(&mut self, instance: &mut Instance<'a>) -> Option> { + for name in instance.exports.names.drain(..) { + let id = gensym::fill(instance.span, &mut instance.id); + self.component_fields_to_append + .push(ComponentField::Export(ComponentExport { + span: instance.span, + name, + kind: ComponentExportKind::instance(instance.span, id), + })); + } + match &mut instance.kind { + InstanceKind::Import { import, ty } => { + let idx = self.expand_component_type_use(ty); + Some(ComponentField::Import(ComponentImport { + span: instance.span, + name: import.name, + item: ItemSig { + span: instance.span, + id: instance.id, + name: None, + kind: ItemSigKind::Instance(ComponentTypeUse::Ref(idx)), + }, + })) + } + InstanceKind::Instantiate { args, .. } => { + for arg in args { + self.expand_instantiation_arg(&mut arg.kind); + } + None + } + InstanceKind::BundleOfExports { .. } => None, + } + } + + fn expand_canonical_func(&mut self, func: &mut CanonicalFunc<'a>) { + match &mut func.kind { + CanonicalFuncKind::Lift { ty, .. } => { + self.expand_component_type_use(ty); + } + CanonicalFuncKind::Lower(_) => {} + } + } + + fn expand_core_func(&mut self, func: &mut CoreFunc<'a>) -> Option> { + match &mut func.kind { + CoreFuncKind::Alias(a) => Some(ComponentField::CoreAlias(CoreAlias { + span: func.span, + id: func.id, + name: func.name, + target: CoreAliasTarget::Export { + instance: a.instance, + name: a.name, + kind: core::ExportKind::Func, + }, + })), + CoreFuncKind::Lower(info) => Some(ComponentField::CanonicalFunc(CanonicalFunc { + span: func.span, + id: func.id, + name: func.name, + kind: CanonicalFuncKind::Lower(mem::take(info)), + })), + } + } + + fn expand_func(&mut self, func: &mut Func<'a>) -> Option> { + for name in func.exports.names.drain(..) { + let id = gensym::fill(func.span, &mut func.id); + self.component_fields_to_append + .push(ComponentField::Export(ComponentExport { + span: func.span, + name, + kind: ComponentExportKind::func(func.span, id), + })); + } + match &mut func.kind { + FuncKind::Import { import, ty } => { + let idx = self.expand_component_type_use(ty); + Some(ComponentField::Import(ComponentImport { + span: func.span, + name: import.name, + item: ItemSig { + span: func.span, + id: func.id, + name: None, + kind: ItemSigKind::Func(ComponentTypeUse::Ref(idx)), + }, + })) + } + FuncKind::Lift { ty, info } => { + let idx = self.expand_component_type_use(ty); + Some(ComponentField::CanonicalFunc(CanonicalFunc { + span: func.span, + id: func.id, + name: func.name, + kind: CanonicalFuncKind::Lift { + ty: ComponentTypeUse::Ref(idx), + info: mem::take(info), + }, + })) + } + FuncKind::Alias(a) => Some(ComponentField::Alias(Alias { + span: func.span, + id: func.id, + name: func.name, + target: AliasTarget::Export { + instance: a.instance, + name: a.name, + kind: ComponentExportAliasKind::Func, + }, + })), + } + } + + fn expand_core_type(&mut self, field: &mut CoreType<'a>) { + match &mut field.def { + CoreTypeDef::Def(_) => {} + CoreTypeDef::Module(m) => self.expand_module_ty(m), + } + + let id = gensym::fill(field.span, &mut field.id); + let index = Index::Id(id); + match &field.def { + CoreTypeDef::Def(_) => {} + CoreTypeDef::Module(t) => t.key().insert(self, index), + } + } + + fn expand_type(&mut self, field: &mut Type<'a>) { + match &mut field.def { + TypeDef::Defined(d) => self.expand_defined_ty(d), + TypeDef::Func(f) => self.expand_func_ty(f), + TypeDef::Component(c) => self.expand_component_ty(c), + TypeDef::Instance(i) => self.expand_instance_ty(i), + } + + let id = gensym::fill(field.span, &mut field.id); + let index = Index::Id(id); + match &field.def { + TypeDef::Defined(t) => t.key().insert(self, index), + TypeDef::Func(t) => t.key().insert(self, index), + TypeDef::Component(t) => t.key().insert(self, index), + TypeDef::Instance(t) => t.key().insert(self, index), + } + } + + fn expand_func_ty(&mut self, ty: &mut ComponentFunctionType<'a>) { + for param in ty.params.iter_mut() { + self.expand_component_val_ty(&mut param.ty); + } + + for result in ty.results.iter_mut() { + self.expand_component_val_ty(&mut result.ty); + } + } + + fn expand_module_ty(&mut self, ty: &mut ModuleType<'a>) { + use crate::core::resolve::types::{FuncKey, TypeKey, TypeReference}; + + // Note that this is a custom implementation from everything else in + // this file since this is using core wasm types instead of component + // types, so a small part of the core wasm expansion process is + // inlined here to handle the `TypeUse` from core wasm. + + let mut func_type_to_idx = HashMap::new(); + let mut to_prepend = Vec::new(); + let mut i = 0; + while i < ty.decls.len() { + match &mut ty.decls[i] { + ModuleTypeDecl::Type(ty) => match &ty.def { + core::TypeDef::Func(f) => { + let id = gensym::fill(ty.span, &mut ty.id); + func_type_to_idx.insert(f.key(), Index::Id(id)); + } + core::TypeDef::Struct(_) => {} + core::TypeDef::Array(_) => {} + }, + ModuleTypeDecl::Alias(_) => {} + ModuleTypeDecl::Import(ty) => { + expand_sig(&mut ty.item, &mut to_prepend, &mut func_type_to_idx); + } + ModuleTypeDecl::Export(_, item) => { + expand_sig(item, &mut to_prepend, &mut func_type_to_idx); + } + } + ty.decls.splice(i..i, to_prepend.drain(..)); + i += 1; + } + + fn expand_sig<'a>( + item: &mut core::ItemSig<'a>, + to_prepend: &mut Vec>, + func_type_to_idx: &mut HashMap, Index<'a>>, + ) { + match &mut item.kind { + core::ItemKind::Func(t) | core::ItemKind::Tag(core::TagType::Exception(t)) => { + // If the index is already filled in then this is skipped + if t.index.is_some() { + return; + } + + // Otherwise the inline type information is used to + // generate a type into this module if necessary. If the + // function type already exists we reuse the same key, + // otherwise a fresh type definition is created and we use + // that one instead. + let ty = t.inline.take().unwrap_or_default(); + let key = ty.key(); + if let Some(idx) = func_type_to_idx.get(&key) { + t.index = Some(*idx); + return; + } + let id = gensym::gen(item.span); + to_prepend.push(ModuleTypeDecl::Type(core::Type { + span: item.span, + id: Some(id), + name: None, + def: key.to_def(item.span), + parent: None, + })); + let idx = Index::Id(id); + t.index = Some(idx); + } + core::ItemKind::Global(_) + | core::ItemKind::Table(_) + | core::ItemKind::Memory(_) => {} + } + } + } + + fn expand_component_ty(&mut self, ty: &mut ComponentType<'a>) { + Expander::default().expand_decls(&mut ty.decls, |e, decl| match decl { + ComponentTypeDecl::CoreType(t) => e.expand_core_type(t), + ComponentTypeDecl::Type(t) => e.expand_type(t), + ComponentTypeDecl::Alias(_) => {} + ComponentTypeDecl::Export(t) => e.expand_item_sig(&mut t.item), + ComponentTypeDecl::Import(t) => e.expand_item_sig(&mut t.item), + }) + } + + fn expand_instance_ty(&mut self, ty: &mut InstanceType<'a>) { + Expander::default().expand_decls(&mut ty.decls, |e, decl| match decl { + InstanceTypeDecl::CoreType(t) => e.expand_core_type(t), + InstanceTypeDecl::Type(t) => e.expand_type(t), + InstanceTypeDecl::Alias(_) => {} + InstanceTypeDecl::Export(t) => e.expand_item_sig(&mut t.item), + }) + } + + fn expand_item_sig(&mut self, ext: &mut ItemSig<'a>) { + match &mut ext.kind { + ItemSigKind::CoreModule(t) => { + self.expand_core_type_use(t); + } + ItemSigKind::Func(t) => { + self.expand_component_type_use(t); + } + ItemSigKind::Component(t) => { + self.expand_component_type_use(t); + } + ItemSigKind::Instance(t) => { + self.expand_component_type_use(t); + } + ItemSigKind::Value(t) => { + self.expand_component_val_ty(&mut t.0); + } + ItemSigKind::Type(_) => {} + } + } + + fn expand_defined_ty(&mut self, ty: &mut ComponentDefinedType<'a>) { + match ty { + ComponentDefinedType::Primitive(_) + | ComponentDefinedType::Flags(_) + | ComponentDefinedType::Enum(_) => {} + ComponentDefinedType::Record(r) => { + for field in r.fields.iter_mut() { + self.expand_component_val_ty(&mut field.ty); + } + } + ComponentDefinedType::Variant(v) => { + for case in v.cases.iter_mut() { + if let Some(ty) = &mut case.ty { + self.expand_component_val_ty(ty); + } + } + } + ComponentDefinedType::List(t) => { + self.expand_component_val_ty(&mut t.element); + } + ComponentDefinedType::Tuple(t) => { + for field in t.fields.iter_mut() { + self.expand_component_val_ty(field); + } + } + ComponentDefinedType::Union(u) => { + for ty in u.types.iter_mut() { + self.expand_component_val_ty(ty); + } + } + ComponentDefinedType::Option(t) => { + self.expand_component_val_ty(&mut t.element); + } + ComponentDefinedType::Result(r) => { + if let Some(ty) = &mut r.ok { + self.expand_component_val_ty(ty); + } + + if let Some(ty) = &mut r.err { + self.expand_component_val_ty(ty); + } + } + } + } + + fn expand_component_val_ty(&mut self, ty: &mut ComponentValType<'a>) { + let inline = match ty { + ComponentValType::Inline(ComponentDefinedType::Primitive(_)) + | ComponentValType::Ref(_) => return, + ComponentValType::Inline(inline) => { + self.expand_defined_ty(inline); + mem::take(inline) + } + }; + // If this inline type has already been defined within this context + // then reuse the previously defined type to avoid injecting too many + // types into the type index space. + if let Some(idx) = inline.key().lookup(self) { + *ty = ComponentValType::Ref(idx); + return; + } + + // And if this type isn't already defined we append it to the index + // space with a fresh and unique name. + let span = Span::from_offset(0); // FIXME(#613): don't manufacture + let id = gensym::gen(span); + + self.types_to_prepend.push(inline.into_any_type(span, id)); + + let idx = Index::Id(id); + *ty = ComponentValType::Ref(idx); + } + + fn expand_core_type_use( + &mut self, + item: &mut CoreTypeUse<'a, T>, + ) -> CoreItemRef<'a, kw::r#type> + where + T: TypeReference<'a>, + { + let span = Span::from_offset(0); // FIXME(#613): don't manufacture + let mut inline = match mem::take(item) { + // If this type-use was already a reference to an existing type + // then we put it back the way it was and return the corresponding + // index. + CoreTypeUse::Ref(idx) => { + *item = CoreTypeUse::Ref(idx.clone()); + return idx; + } + + // ... otherwise with an inline type definition we go into + // processing below. + CoreTypeUse::Inline(inline) => inline, + }; + inline.expand(self); + + // If this inline type has already been defined within this context + // then reuse the previously defined type to avoid injecting too many + // types into the type index space. + if let Some(idx) = inline.key().lookup(self) { + let ret = CoreItemRef { + idx, + kind: kw::r#type(span), + export_name: None, + }; + *item = CoreTypeUse::Ref(ret.clone()); + return ret; + } + + // And if this type isn't already defined we append it to the index + // space with a fresh and unique name. + let id = gensym::gen(span); + + self.types_to_prepend.push(inline.into_any_type(span, id)); + + let idx = Index::Id(id); + let ret = CoreItemRef { + idx, + kind: kw::r#type(span), + export_name: None, + }; + + *item = CoreTypeUse::Ref(ret.clone()); + ret + } + + fn expand_component_type_use( + &mut self, + item: &mut ComponentTypeUse<'a, T>, + ) -> ItemRef<'a, kw::r#type> + where + T: TypeReference<'a>, + { + let span = Span::from_offset(0); // FIXME(#613): don't manufacture + let mut inline = match mem::take(item) { + // If this type-use was already a reference to an existing type + // then we put it back the way it was and return the corresponding + // index. + ComponentTypeUse::Ref(idx) => { + *item = ComponentTypeUse::Ref(idx.clone()); + return idx; + } + + // ... otherwise with an inline type definition we go into + // processing below. + ComponentTypeUse::Inline(inline) => inline, + }; + inline.expand(self); + + // If this inline type has already been defined within this context + // then reuse the previously defined type to avoid injecting too many + // types into the type index space. + if let Some(idx) = inline.key().lookup(self) { + let ret = ItemRef { + idx, + kind: kw::r#type(span), + export_names: Vec::new(), + }; + *item = ComponentTypeUse::Ref(ret.clone()); + return ret; + } + + // And if this type isn't already defined we append it to the index + // space with a fresh and unique name. + let id = gensym::gen(span); + + self.types_to_prepend.push(inline.into_any_type(span, id)); + + let idx = Index::Id(id); + let ret = ItemRef { + idx, + kind: kw::r#type(span), + export_names: Vec::new(), + }; + + *item = ComponentTypeUse::Ref(ret.clone()); + ret + } + + fn expand_core_instantiation_arg(&mut self, arg: &mut CoreInstantiationArgKind<'a>) { + let (span, exports) = match arg { + CoreInstantiationArgKind::Instance(_) => return, + CoreInstantiationArgKind::BundleOfExports(span, exports) => (*span, mem::take(exports)), + }; + let id = gensym::gen(span); + self.component_fields_to_prepend + .push(ComponentField::CoreInstance(CoreInstance { + span, + id: Some(id), + name: None, + kind: CoreInstanceKind::BundleOfExports(exports), + })); + *arg = CoreInstantiationArgKind::Instance(CoreItemRef { + kind: kw::instance(span), + idx: Index::Id(id), + export_name: None, + }); + } + + fn expand_instantiation_arg(&mut self, arg: &mut InstantiationArgKind<'a>) { + let (span, exports) = match arg { + InstantiationArgKind::Item(_) => return, + InstantiationArgKind::BundleOfExports(span, exports) => (*span, mem::take(exports)), + }; + let id = gensym::gen(span); + self.component_fields_to_prepend + .push(ComponentField::Instance(Instance { + span, + id: Some(id), + name: None, + exports: Default::default(), + kind: InstanceKind::BundleOfExports(exports), + })); + *arg = InstantiationArgKind::Item(ComponentExportKind::instance(span, id)); + } +} + +trait TypeReference<'a> { + type Key: TypeKey<'a>; + fn key(&self) -> Self::Key; + fn expand(&mut self, cx: &mut Expander<'a>); + fn into_any_type(self, span: Span, id: Id<'a>) -> AnyType<'a>; +} + +impl<'a> TypeReference<'a> for ComponentDefinedType<'a> { + type Key = Todo; // FIXME(#598): should implement this + + fn key(&self) -> Self::Key { + Todo + } + + fn expand(&mut self, cx: &mut Expander<'a>) { + cx.expand_defined_ty(self) + } + + fn into_any_type(self, span: Span, id: Id<'a>) -> AnyType<'a> { + AnyType::Component(Type { + span, + id: Some(id), + name: None, + exports: Default::default(), + def: TypeDef::Defined(self), + }) + } +} + +impl<'a> TypeReference<'a> for ComponentType<'a> { + type Key = Todo; // FIXME(#598): should implement this + + fn key(&self) -> Self::Key { + Todo + } + + fn expand(&mut self, cx: &mut Expander<'a>) { + cx.expand_component_ty(self) + } + + fn into_any_type(self, span: Span, id: Id<'a>) -> AnyType<'a> { + AnyType::Component(Type { + span, + id: Some(id), + name: None, + exports: Default::default(), + def: TypeDef::Component(self), + }) + } +} + +impl<'a> TypeReference<'a> for ModuleType<'a> { + type Key = Todo; // FIXME(#598): should implement this + + fn key(&self) -> Self::Key { + Todo + } + + fn expand(&mut self, cx: &mut Expander<'a>) { + cx.expand_module_ty(self) + } + + fn into_any_type(self, span: Span, id: Id<'a>) -> AnyType<'a> { + AnyType::Core(CoreType { + span, + id: Some(id), + name: None, + def: CoreTypeDef::Module(self), + }) + } +} + +impl<'a> TypeReference<'a> for InstanceType<'a> { + type Key = Todo; // FIXME(#598): should implement this + + fn key(&self) -> Self::Key { + Todo + } + + fn expand(&mut self, cx: &mut Expander<'a>) { + cx.expand_instance_ty(self) + } + + fn into_any_type(self, span: Span, id: Id<'a>) -> AnyType<'a> { + AnyType::Component(Type { + span, + id: Some(id), + name: None, + exports: Default::default(), + def: TypeDef::Instance(self), + }) + } +} + +impl<'a> TypeReference<'a> for ComponentFunctionType<'a> { + type Key = Todo; // FIXME(#598): should implement this + + fn key(&self) -> Self::Key { + Todo + } + + fn expand(&mut self, cx: &mut Expander<'a>) { + cx.expand_func_ty(self) + } + + fn into_any_type(self, span: Span, id: Id<'a>) -> AnyType<'a> { + AnyType::Component(Type { + span, + id: Some(id), + name: None, + exports: Default::default(), + def: TypeDef::Func(self), + }) + } +} + +trait TypeKey<'a> { + fn lookup(&self, cx: &Expander<'a>) -> Option>; + fn insert(&self, cx: &mut Expander<'a>, index: Index<'a>); +} + +struct Todo; + +impl<'a> TypeKey<'a> for Todo { + fn lookup(&self, _cx: &Expander<'a>) -> Option> { + None + } + + fn insert(&self, _cx: &mut Expander<'a>, _index: Index<'a>) {} +} diff --git a/crates/wastlhw/src/component/export.rs b/crates/wastlhw/src/component/export.rs new file mode 100644 index 000000000..a3b2bd7c0 --- /dev/null +++ b/crates/wastlhw/src/component/export.rs @@ -0,0 +1,141 @@ +use super::ItemRef; +use crate::kw; +use crate::parser::{Cursor, Parse, Parser, Peek, Result}; +use crate::token::{Id, Index, Span}; + +/// An entry in a WebAssembly component's export section. +#[derive(Debug)] +pub struct ComponentExport<'a> { + /// Where this export was defined. + pub span: Span, + /// The name of this export from the component. + pub name: &'a str, + /// The kind of export. + pub kind: ComponentExportKind<'a>, +} + +impl<'a> Parse<'a> for ComponentExport<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let name = parser.parse()?; + let kind = parser.parse()?; + Ok(ComponentExport { span, name, kind }) + } +} + +impl<'a> Parse<'a> for Vec> { + fn parse(parser: Parser<'a>) -> Result { + let mut exports = Vec::new(); + while !parser.is_empty() { + exports.push(parser.parens(|parser| parser.parse())?); + } + Ok(exports) + } +} + +/// The kind of exported item. +#[derive(Debug)] +pub enum ComponentExportKind<'a> { + /// The export is a core module. + /// + /// Note this isn't a core item ref as currently only + /// components can export core modules. + CoreModule(ItemRef<'a, kw::module>), + /// The export is a function. + Func(ItemRef<'a, kw::func>), + /// The export is a value. + Value(ItemRef<'a, kw::value>), + /// The export is a type. + Type(ItemRef<'a, kw::r#type>), + /// The export is a component. + Component(ItemRef<'a, kw::component>), + /// The export is an instance. + Instance(ItemRef<'a, kw::instance>), +} + +impl<'a> ComponentExportKind<'a> { + pub(crate) fn module(span: Span, id: Id<'a>) -> Self { + Self::CoreModule(ItemRef { + kind: kw::module(span), + idx: Index::Id(id), + export_names: Default::default(), + }) + } + + pub(crate) fn component(span: Span, id: Id<'a>) -> Self { + Self::Component(ItemRef { + kind: kw::component(span), + idx: Index::Id(id), + export_names: Default::default(), + }) + } + + pub(crate) fn instance(span: Span, id: Id<'a>) -> Self { + Self::Instance(ItemRef { + kind: kw::instance(span), + idx: Index::Id(id), + export_names: Default::default(), + }) + } + + pub(crate) fn func(span: Span, id: Id<'a>) -> Self { + Self::Func(ItemRef { + kind: kw::func(span), + idx: Index::Id(id), + export_names: Default::default(), + }) + } +} + +impl<'a> Parse<'a> for ComponentExportKind<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parens(|parser| { + let mut l = parser.lookahead1(); + if l.peek::() { + // Remove core prefix + parser.parse::()?; + Ok(Self::CoreModule(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Func(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Value(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Type(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Component(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Instance(parser.parse()?)) + } else { + Err(l.error()) + } + }) + } +} + +impl Peek for ComponentExportKind<'_> { + fn peek(cursor: Cursor) -> bool { + let cursor = match cursor.lparen() { + Some(c) => c, + None => return false, + }; + + let cursor = match cursor.keyword() { + Some(("core", c)) => match c.keyword() { + Some(("module", c)) => c, + _ => return false, + }, + Some(("func", c)) + | Some(("value", c)) + | Some(("type", c)) + | Some(("component", c)) + | Some(("instance", c)) => c, + _ => return false, + }; + + Index::peek(cursor) + } + + fn display() -> &'static str { + "component export" + } +} diff --git a/crates/wastlhw/src/component/func.rs b/crates/wastlhw/src/component/func.rs new file mode 100644 index 000000000..c265b3cbb --- /dev/null +++ b/crates/wastlhw/src/component/func.rs @@ -0,0 +1,373 @@ +use crate::component::*; +use crate::core; +use crate::kw; +use crate::parser::{Parse, Parser, Result}; +use crate::token::{Id, Index, LParen, NameAnnotation, Span}; + +/// A declared core function. +/// +/// This is a member of both the core alias and canon sections. +#[derive(Debug)] +pub struct CoreFunc<'a> { + /// Where this `core func` was defined. + pub span: Span, + /// An identifier that this function is resolved with (optionally) for name + /// resolution. + pub id: Option>, + /// An optional name for this function stored in the custom `name` section. + pub name: Option>, + /// The kind of core function. + pub kind: CoreFuncKind<'a>, +} + +impl<'a> Parse<'a> for CoreFunc<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + parser.parse::()?; + let id = parser.parse()?; + let name = parser.parse()?; + let kind = parser.parse()?; + + Ok(Self { + span, + id, + name, + kind, + }) + } +} + +/// Represents the kind of core functions. +#[derive(Debug)] +pub enum CoreFuncKind<'a> { + /// The core function is defined in terms of lowering a component function. + /// + /// The core function is actually a member of the canon section. + Lower(CanonLower<'a>), + /// The core function is defined in terms of aliasing a module instance export. + /// + /// The core function is actually a member of the core alias section. + Alias(InlineExportAlias<'a>), +} + +impl<'a> Parse<'a> for CoreFuncKind<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parens(|parser| { + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + Ok(Self::Lower(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Alias(parser.parse()?)) + } else { + Err(l.error()) + } + }) + } +} + +/// A declared component function. +/// +/// This may be a member of the import, alias, or canon sections. +#[derive(Debug)] +pub struct Func<'a> { + /// Where this `func` was defined. + pub span: Span, + /// An identifier that this function is resolved with (optionally) for name + /// resolution. + pub id: Option>, + /// An optional name for this function stored in the custom `name` section. + pub name: Option>, + /// If present, inline export annotations which indicate names this + /// definition should be exported under. + pub exports: core::InlineExport<'a>, + /// The kind of function. + pub kind: FuncKind<'a>, +} + +impl<'a> Parse<'a> for Func<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let id = parser.parse()?; + let name = parser.parse()?; + let exports = parser.parse()?; + let kind = parser.parse()?; + + Ok(Self { + span, + id, + name, + exports, + kind, + }) + } +} + +/// Represents the kind of component functions. +#[derive(Debug)] +pub enum FuncKind<'a> { + /// A function which is actually defined as an import, such as: + /// + /// ```text + /// (func (import "foo") (param string)) + /// ``` + Import { + /// The import name of this import. + import: InlineImport<'a>, + /// The type that this function will have. + ty: ComponentTypeUse<'a, ComponentFunctionType<'a>>, + }, + /// The function is defined in terms of lifting a core function. + /// + /// The function is actually a member of the canon section. + Lift { + /// The lifted function's type. + ty: ComponentTypeUse<'a, ComponentFunctionType<'a>>, + /// Information relating to the lifting of the core function. + info: CanonLift<'a>, + }, + /// The function is defined in terms of aliasing a component instance export. + /// + /// The function is actually a member of the alias section. + Alias(InlineExportAlias<'a>), +} + +impl<'a> Parse<'a> for FuncKind<'a> { + fn parse(parser: Parser<'a>) -> Result { + if let Some(import) = parser.parse()? { + Ok(Self::Import { + import, + ty: parser.parse()?, + }) + } else if parser.peek::() && parser.peek2::() { + parser.parens(|parser| Ok(Self::Alias(parser.parse()?))) + } else { + Ok(Self::Lift { + ty: parser.parse()?, + info: parser.parens(|parser| { + parser.parse::()?; + parser.parse() + })?, + }) + } + } +} + +/// A WebAssembly canonical function to be inserted into a component. +/// +/// This is a member of the canonical section. +#[derive(Debug)] +pub struct CanonicalFunc<'a> { + /// Where this `func` was defined. + pub span: Span, + /// An identifier that this function is resolved with (optionally) for name + /// resolution. + pub id: Option>, + /// An optional name for this function stored in the custom `name` section. + pub name: Option>, + /// What kind of function this is, be it a lowered or lifted function. + pub kind: CanonicalFuncKind<'a>, +} + +impl<'a> Parse<'a> for CanonicalFunc<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + + if parser.peek::() { + let info = parser.parse()?; + let (id, name, ty) = parser.parens(|parser| { + parser.parse::()?; + let id = parser.parse()?; + let name = parser.parse()?; + let ty = parser.parse()?; + Ok((id, name, ty)) + })?; + + Ok(Self { + span, + id, + name, + kind: CanonicalFuncKind::Lift { info, ty }, + }) + } else if parser.peek::() { + let info = parser.parse()?; + let (id, name) = parser.parens(|parser| { + parser.parse::()?; + parser.parse::()?; + let id = parser.parse()?; + let name = parser.parse()?; + Ok((id, name)) + })?; + + Ok(Self { + span, + id, + name, + kind: CanonicalFuncKind::Lower(info), + }) + } else { + Err(parser.error("expected `canon lift` or `canon lower`")) + } + } +} + +/// Possible ways to define a canonical function in the text format. +#[derive(Debug)] +pub enum CanonicalFuncKind<'a> { + /// A canonical function that is defined in terms of lifting a core function. + Lift { + /// The lifted function's type. + ty: ComponentTypeUse<'a, ComponentFunctionType<'a>>, + /// Information relating to the lifting of the core function. + info: CanonLift<'a>, + }, + /// A canonical function that is defined in terms of lowering a component function. + Lower(CanonLower<'a>), +} + +/// Information relating to lifting a core function. +#[derive(Debug)] +pub struct CanonLift<'a> { + /// The core function being lifted. + pub func: CoreItemRef<'a, kw::func>, + /// The canonical options for the lifting. + pub opts: Vec>, +} + +impl<'a> Parse<'a> for CanonLift<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + + Ok(Self { + func: parser.parens(|parser| { + parser.parse::()?; + parser.parse() + })?, + opts: parser.parse()?, + }) + } +} + +impl Default for CanonLift<'_> { + fn default() -> Self { + let span = Span::from_offset(0); + Self { + func: CoreItemRef { + kind: kw::func(span), + idx: Index::Num(0, span), + export_name: None, + }, + opts: Vec::new(), + } + } +} + +/// Information relating to lowering a component function. +#[derive(Debug)] +pub struct CanonLower<'a> { + /// The function being lowered. + pub func: ItemRef<'a, kw::func>, + /// The canonical options for the lowering. + pub opts: Vec>, +} + +impl<'a> Parse<'a> for CanonLower<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + + Ok(Self { + func: parser.parens(|parser| parser.parse())?, + opts: parser.parse()?, + }) + } +} + +impl Default for CanonLower<'_> { + fn default() -> Self { + let span = Span::from_offset(0); + Self { + func: ItemRef { + kind: kw::func(span), + idx: Index::Num(0, span), + export_names: Vec::new(), + }, + opts: Vec::new(), + } + } +} + +#[derive(Debug)] +/// Canonical ABI options. +pub enum CanonOpt<'a> { + /// Encode strings as UTF-8. + StringUtf8, + /// Encode strings as UTF-16. + StringUtf16, + /// Encode strings as "compact UTF-16". + StringLatin1Utf16, + /// Use the specified memory for canonical ABI memory access. + Memory(CoreItemRef<'a, kw::memory>), + /// Use the specified reallocation function for memory allocations. + Realloc(CoreItemRef<'a, kw::func>), + /// Call the specified function after the lifted function has returned. + PostReturn(CoreItemRef<'a, kw::func>), +} + +impl<'a> Parse<'a> for CanonOpt<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + Ok(Self::StringUtf8) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::StringUtf16) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::StringLatin1Utf16) + } else if l.peek::() { + parser.parens(|parser| { + let mut l = parser.lookahead1(); + if l.peek::() { + let span = parser.parse::()?.0; + Ok(CanonOpt::Memory(parse_trailing_item_ref( + kw::memory(span), + parser, + )?)) + } else if l.peek::() { + parser.parse::()?; + Ok(CanonOpt::Realloc( + parser.parse::>()?.0, + )) + } else if l.peek::() { + parser.parse::()?; + Ok(CanonOpt::PostReturn( + parser.parse::>()?.0, + )) + } else { + Err(l.error()) + } + }) + } else { + Err(l.error()) + } + } +} + +fn parse_trailing_item_ref(kind: T, parser: Parser) -> Result> { + Ok(CoreItemRef { + kind, + idx: parser.parse()?, + export_name: parser.parse()?, + }) +} + +impl<'a> Parse<'a> for Vec> { + fn parse(parser: Parser<'a>) -> Result { + let mut funcs = Vec::new(); + while !parser.is_empty() { + funcs.push(parser.parse()?); + } + Ok(funcs) + } +} diff --git a/crates/wastlhw/src/component/import.rs b/crates/wastlhw/src/component/import.rs new file mode 100644 index 000000000..18b92dfd1 --- /dev/null +++ b/crates/wastlhw/src/component/import.rs @@ -0,0 +1,150 @@ +use crate::component::*; +use crate::kw; +use crate::parser::{Cursor, Parse, Parser, Peek, Result}; +use crate::token::Index; +use crate::token::{Id, NameAnnotation, Span}; + +/// An `import` statement and entry in a WebAssembly component. +#[derive(Debug)] +pub struct ComponentImport<'a> { + /// Where this `import` was defined + pub span: Span, + /// The name of the item to import. + pub name: &'a str, + /// The item that's being imported. + pub item: ItemSig<'a>, +} + +impl<'a> Parse<'a> for ComponentImport<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let name = parser.parse()?; + let item = parser.parens(|p| p.parse())?; + Ok(ComponentImport { span, name, item }) + } +} + +/// An item signature for imported items. +#[derive(Debug)] +pub struct ItemSig<'a> { + /// Where this item is defined in the source. + pub span: Span, + /// An optional identifier used during name resolution to refer to this item + /// from the rest of the component. + pub id: Option>, + /// An optional name which, for functions, will be stored in the + /// custom `name` section. + pub name: Option>, + /// What kind of item this is. + pub kind: ItemSigKind<'a>, +} + +impl<'a> Parse<'a> for ItemSig<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + let (span, parse_kind): (_, fn(Parser<'a>) -> Result) = if l.peek::() + { + let span = parser.parse::()?.0; + parser.parse::()?; + (span, |parser| Ok(ItemSigKind::CoreModule(parser.parse()?))) + } else if l.peek::() { + let span = parser.parse::()?.0; + (span, |parser| Ok(ItemSigKind::Func(parser.parse()?))) + } else if l.peek::() { + let span = parser.parse::()?.0; + (span, |parser| Ok(ItemSigKind::Component(parser.parse()?))) + } else if l.peek::() { + let span = parser.parse::()?.0; + (span, |parser| Ok(ItemSigKind::Instance(parser.parse()?))) + } else if l.peek::() { + let span = parser.parse::()?.0; + (span, |parser| Ok(ItemSigKind::Value(parser.parse()?))) + } else if l.peek::() { + let span = parser.parse::()?.0; + (span, |parser| { + Ok(ItemSigKind::Type(parser.parens(|parser| parser.parse())?)) + }) + } else { + return Err(l.error()); + }; + Ok(Self { + span, + id: parser.parse()?, + name: parser.parse()?, + kind: parse_kind(parser)?, + }) + } +} + +/// The kind of signatures for imported items. +#[derive(Debug)] +pub enum ItemSigKind<'a> { + /// The item signature is for a core module. + CoreModule(CoreTypeUse<'a, ModuleType<'a>>), + /// The item signature is for a function. + Func(ComponentTypeUse<'a, ComponentFunctionType<'a>>), + /// The item signature is for a component. + Component(ComponentTypeUse<'a, ComponentType<'a>>), + /// The item signature is for an instance. + Instance(ComponentTypeUse<'a, InstanceType<'a>>), + /// The item signature is for a value. + Value(ComponentValTypeUse<'a>), + /// The item signature is for a type. + Type(TypeBounds<'a>), +} + +/// Represents the bounds applied to types being imported. +#[derive(Debug)] +pub enum TypeBounds<'a> { + /// The equality type bounds. + Eq(Index<'a>), +} + +impl<'a> Parse<'a> for TypeBounds<'a> { + fn parse(parser: Parser<'a>) -> Result { + // Currently this is the only supported type bounds. + parser.parse::()?; + Ok(Self::Eq(parser.parse()?)) + } +} + +/// A listing of a inline `(import "foo")` statement. +/// +/// This is the same as `core::InlineImport` except only one string import is +/// required. +#[derive(Debug, Copy, Clone)] +pub struct InlineImport<'a> { + /// The name of the item being imported. + pub name: &'a str, +} + +impl<'a> Parse<'a> for InlineImport<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parens(|p| { + p.parse::()?; + Ok(InlineImport { name: p.parse()? }) + }) + } +} + +impl Peek for InlineImport<'_> { + fn peek(cursor: Cursor<'_>) -> bool { + let cursor = match cursor.lparen() { + Some(cursor) => cursor, + None => return false, + }; + let cursor = match cursor.keyword() { + Some(("import", cursor)) => cursor, + _ => return false, + }; + let cursor = match cursor.string() { + Some((_, cursor)) => cursor, + None => return false, + }; + cursor.rparen().is_some() + } + + fn display() -> &'static str { + "inline import" + } +} diff --git a/crates/wastlhw/src/component/instance.rs b/crates/wastlhw/src/component/instance.rs new file mode 100644 index 000000000..8c8c1edb3 --- /dev/null +++ b/crates/wastlhw/src/component/instance.rs @@ -0,0 +1,296 @@ +use crate::component::*; +use crate::core; +use crate::kw; +use crate::parser::{Parse, Parser, Result}; +use crate::token::{Id, LParen, NameAnnotation, Span}; + +/// A core instance defined by instantiation or exporting core items. +#[derive(Debug)] +pub struct CoreInstance<'a> { + /// Where this `core instance` was defined. + pub span: Span, + /// An identifier that this instance is resolved with (optionally) for name + /// resolution. + pub id: Option>, + /// An optional name for this instance stored in the custom `name` section. + pub name: Option>, + /// What kind of instance this is. + pub kind: CoreInstanceKind<'a>, +} + +impl<'a> Parse<'a> for CoreInstance<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + parser.parse::()?; + let id = parser.parse()?; + let name = parser.parse()?; + let kind = parser.parse()?; + + Ok(Self { + span, + id, + name, + kind, + }) + } +} + +/// The kinds of core instances in the text format. +#[derive(Debug)] +pub enum CoreInstanceKind<'a> { + /// Instantiate a core module. + Instantiate { + /// The module being instantiated. + module: ItemRef<'a, kw::module>, + /// Arguments used to instantiate the instance. + args: Vec>, + }, + /// The instance is defined by exporting local items as an instance. + BundleOfExports(Vec>), +} + +impl<'a> Parse<'a> for CoreInstanceKind<'a> { + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::() && parser.peek2::() { + parser.parens(|parser| { + parser.parse::()?; + Ok(Self::Instantiate { + module: parser.parse::>()?.0, + args: parser.parse()?, + }) + }) + } else { + Ok(Self::BundleOfExports(parser.parse()?)) + } + } +} + +impl Default for kw::module { + fn default() -> kw::module { + kw::module(Span::from_offset(0)) + } +} + +/// An argument to instantiate a core module. +#[derive(Debug)] +pub struct CoreInstantiationArg<'a> { + /// The name of the instantiation argument. + pub name: &'a str, + /// The kind of core instantiation argument. + pub kind: CoreInstantiationArgKind<'a>, +} + +impl<'a> Parse<'a> for CoreInstantiationArg<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + Ok(Self { + name: parser.parse()?, + kind: parser.parse()?, + }) + } +} + +impl<'a> Parse<'a> for Vec> { + fn parse(parser: Parser<'a>) -> Result { + let mut args = Vec::new(); + while !parser.is_empty() { + args.push(parser.parens(|parser| parser.parse())?); + } + Ok(args) + } +} + +/// The kind of core instantiation argument. +#[derive(Debug)] +pub enum CoreInstantiationArgKind<'a> { + /// The argument is a reference to an instance. + Instance(CoreItemRef<'a, kw::instance>), + /// The argument is an instance created from local exported core items. + /// + /// This is syntactic sugar for defining a core instance and also using it + /// as an instantiation argument. + BundleOfExports(Span, Vec>), +} + +impl<'a> Parse<'a> for CoreInstantiationArgKind<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parens(|parser| { + if let Some(r) = parser.parse()? { + Ok(Self::Instance(r)) + } else { + let span = parser.parse::()?.0; + Ok(Self::BundleOfExports(span, parser.parse()?)) + } + }) + } +} + +/// An exported item as part of a core instance. +#[derive(Debug)] +pub struct CoreInstanceExport<'a> { + /// Where this export was defined. + pub span: Span, + /// The name of this export from the instance. + pub name: &'a str, + /// What's being exported from the instance. + pub item: CoreItemRef<'a, core::ExportKind>, +} + +impl<'a> Parse<'a> for CoreInstanceExport<'a> { + fn parse(parser: Parser<'a>) -> Result { + Ok(Self { + span: parser.parse::()?.0, + name: parser.parse()?, + item: parser.parens(|parser| parser.parse())?, + }) + } +} + +impl<'a> Parse<'a> for Vec> { + fn parse(parser: Parser<'a>) -> Result { + let mut exports = Vec::new(); + while !parser.is_empty() { + exports.push(parser.parens(|parser| parser.parse())?); + } + Ok(exports) + } +} + +/// A component instance defined by instantiation or exporting items. +#[derive(Debug)] +pub struct Instance<'a> { + /// Where this `instance` was defined. + pub span: Span, + /// An identifier that this instance is resolved with (optionally) for name + /// resolution. + pub id: Option>, + /// An optional name for this instance stored in the custom `name` section. + pub name: Option>, + /// If present, inline export annotations which indicate names this + /// definition should be exported under. + pub exports: core::InlineExport<'a>, + /// What kind of instance this is. + pub kind: InstanceKind<'a>, +} + +impl<'a> Parse<'a> for Instance<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let id = parser.parse()?; + let name = parser.parse()?; + let exports = parser.parse()?; + let kind = parser.parse()?; + + Ok(Self { + span, + id, + name, + exports, + kind, + }) + } +} + +/// The kinds of instances in the text format. +#[derive(Debug)] +pub enum InstanceKind<'a> { + /// The `(instance (import "x"))` sugar syntax + Import { + /// The name of the import + import: InlineImport<'a>, + /// The type of the instance being imported + ty: ComponentTypeUse<'a, InstanceType<'a>>, + }, + /// Instantiate a component. + Instantiate { + /// The component being instantiated. + component: ItemRef<'a, kw::component>, + /// Arguments used to instantiate the instance. + args: Vec>, + }, + /// The instance is defined by exporting local items as an instance. + BundleOfExports(Vec>), +} + +impl<'a> Parse<'a> for InstanceKind<'a> { + fn parse(parser: Parser<'a>) -> Result { + if let Some(import) = parser.parse()? { + return Ok(Self::Import { + import, + ty: parser.parse()?, + }); + } + + if parser.peek::() && parser.peek2::() { + parser.parens(|parser| { + parser.parse::()?; + Ok(Self::Instantiate { + component: parser.parse::>()?.0, + args: parser.parse()?, + }) + }) + } else { + Ok(Self::BundleOfExports(parser.parse()?)) + } + } +} + +impl Default for kw::component { + fn default() -> kw::component { + kw::component(Span::from_offset(0)) + } +} + +/// An argument to instantiate a component. +#[derive(Debug)] +pub struct InstantiationArg<'a> { + /// The name of the instantiation argument. + pub name: &'a str, + /// The kind of instantiation argument. + pub kind: InstantiationArgKind<'a>, +} + +impl<'a> Parse<'a> for InstantiationArg<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + Ok(Self { + name: parser.parse()?, + kind: parser.parse()?, + }) + } +} + +impl<'a> Parse<'a> for Vec> { + fn parse(parser: Parser<'a>) -> Result { + let mut args = Vec::new(); + while !parser.is_empty() { + args.push(parser.parens(|parser| parser.parse())?); + } + Ok(args) + } +} + +/// The kind of instantiation argument. +#[derive(Debug)] +pub enum InstantiationArgKind<'a> { + /// The argument is a reference to a component item. + Item(ComponentExportKind<'a>), + /// The argument is an instance created from local exported items. + /// + /// This is syntactic sugar for defining an instance and also using it + /// as an instantiation argument. + BundleOfExports(Span, Vec>), +} + +impl<'a> Parse<'a> for InstantiationArgKind<'a> { + fn parse(parser: Parser<'a>) -> Result { + if let Some(item) = parser.parse()? { + Ok(Self::Item(item)) + } else { + parser.parens(|parser| { + let span = parser.parse::()?.0; + Ok(Self::BundleOfExports(span, parser.parse()?)) + }) + } + } +} diff --git a/crates/wastlhw/src/component/item_ref.rs b/crates/wastlhw/src/component/item_ref.rs new file mode 100644 index 000000000..c3bbf2f9f --- /dev/null +++ b/crates/wastlhw/src/component/item_ref.rs @@ -0,0 +1,154 @@ +use crate::parser::{Cursor, Parse, Parser, Peek, Result}; +use crate::token::Index; + +fn peek(cursor: Cursor) -> bool { + // This is a little fancy because when parsing something like: + // + // (type (component (type $foo))) + // + // we need to disambiguate that from + // + // (type (component (type $foo (func)))) + // + // where the first is a type reference and the second is an inline + // component type defining a type internally. The peek here not only + // peeks for `K` but also for the index and possibly trailing + // strings. + + // Peek for the given keyword type + if !K::peek(cursor) { + return false; + } + + // Move past the given keyword + let cursor = match cursor.keyword() { + Some((_, c)) => c, + _ => return false, + }; + + // Peek an id or integer index, followed by `)` or string to disambiguate + match cursor + .id() + .map(|p| p.1) + .or_else(|| cursor.integer().map(|p| p.1)) + { + Some(cursor) => cursor.rparen().is_some() || cursor.string().is_some(), + None => false, + } +} + +/// Parses core item references. +#[derive(Clone, Debug)] +pub struct CoreItemRef<'a, K> { + /// The item kind being parsed. + pub kind: K, + /// The item or instance reference. + pub idx: Index<'a>, + /// Export name to resolve the item from. + pub export_name: Option<&'a str>, +} + +impl<'a, K: Parse<'a>> Parse<'a> for CoreItemRef<'a, K> { + fn parse(parser: Parser<'a>) -> Result { + // This does not parse the surrounding `(` and `)` because + // core prefix is context dependent and only the caller knows if it should be + // present for core references; therefore, the caller parses the parens and any core prefix + let kind = parser.parse::()?; + let idx = parser.parse()?; + let export_name = parser.parse()?; + Ok(Self { + kind, + idx, + export_name, + }) + } +} + +impl<'a, K: Peek> Peek for CoreItemRef<'a, K> { + fn peek(cursor: Cursor<'_>) -> bool { + peek::(cursor) + } + + fn display() -> &'static str { + "a core item reference" + } +} + +/// Parses component item references. +#[derive(Clone, Debug)] +pub struct ItemRef<'a, K> { + /// The item kind being parsed. + pub kind: K, + /// The item or instance reference. + pub idx: Index<'a>, + /// Export names to resolve the item from. + pub export_names: Vec<&'a str>, +} + +impl<'a, K: Parse<'a>> Parse<'a> for ItemRef<'a, K> { + fn parse(parser: Parser<'a>) -> Result { + let kind = parser.parse::()?; + let idx = parser.parse()?; + let mut export_names = Vec::new(); + while !parser.is_empty() { + export_names.push(parser.parse()?); + } + Ok(Self { + kind, + idx, + export_names, + }) + } +} + +impl<'a, K: Peek> Peek for ItemRef<'a, K> { + fn peek(cursor: Cursor<'_>) -> bool { + peek::(cursor) + } + + fn display() -> &'static str { + "a component item reference" + } +} + +/// Convenience structure to parse `$f` or `(item $f)`. +#[derive(Clone, Debug)] +pub struct IndexOrRef<'a, K>(pub ItemRef<'a, K>); + +impl<'a, K> Parse<'a> for IndexOrRef<'a, K> +where + K: Parse<'a> + Default, +{ + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::>() { + Ok(IndexOrRef(ItemRef { + kind: K::default(), + idx: parser.parse()?, + export_names: Vec::new(), + })) + } else { + Ok(IndexOrRef(parser.parens(|p| p.parse())?)) + } + } +} + +/// Convenience structure to parse `$f` or `(item $f)`. +#[derive(Clone, Debug)] +pub struct IndexOrCoreRef<'a, K>(pub CoreItemRef<'a, K>); + +impl<'a, K> Parse<'a> for IndexOrCoreRef<'a, K> +where + K: Parse<'a> + Default, +{ + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::>() { + Ok(IndexOrCoreRef(CoreItemRef { + kind: K::default(), + idx: parser.parse()?, + export_name: None, + })) + } else { + Ok(IndexOrCoreRef(parser.parens(|p| p.parse())?)) + } + } +} diff --git a/crates/wastlhw/src/component/module.rs b/crates/wastlhw/src/component/module.rs new file mode 100644 index 000000000..a8c606136 --- /dev/null +++ b/crates/wastlhw/src/component/module.rs @@ -0,0 +1,75 @@ +use crate::component::*; +use crate::core; +use crate::kw; +use crate::parser::{Parse, Parser, Result}; +use crate::token::{Id, NameAnnotation, Span}; + +/// A core WebAssembly module to be created as part of a component. +/// +/// This is a member of the core module section. +#[derive(Debug)] +pub struct CoreModule<'a> { + /// Where this `core module` was defined. + pub span: Span, + /// An identifier that this module is resolved with (optionally) for name + /// resolution. + pub id: Option>, + /// An optional name for this module stored in the custom `name` section. + pub name: Option>, + /// If present, inline export annotations which indicate names this + /// definition should be exported under. + pub exports: core::InlineExport<'a>, + /// What kind of module this is, be it an inline-defined or imported one. + pub kind: CoreModuleKind<'a>, +} + +/// Possible ways to define a core module in the text format. +#[derive(Debug)] +pub enum CoreModuleKind<'a> { + /// A core module which is actually defined as an import + Import { + /// Where this core module is imported from + import: InlineImport<'a>, + /// The type that this core module will have. + ty: CoreTypeUse<'a, ModuleType<'a>>, + }, + + /// Modules that are defined inline. + Inline { + /// Fields in the core module. + fields: Vec>, + }, +} + +impl<'a> Parse<'a> for CoreModule<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.depth_check()?; + + let span = parser.parse::()?.0; + parser.parse::()?; + let id = parser.parse()?; + let name = parser.parse()?; + let exports = parser.parse()?; + + let kind = if let Some(import) = parser.parse()? { + CoreModuleKind::Import { + import, + ty: parser.parse()?, + } + } else { + let mut fields = Vec::new(); + while !parser.is_empty() { + fields.push(parser.parens(|p| p.parse())?); + } + CoreModuleKind::Inline { fields } + }; + + Ok(Self { + span, + id, + name, + exports, + kind, + }) + } +} diff --git a/crates/wastlhw/src/component/resolve.rs b/crates/wastlhw/src/component/resolve.rs new file mode 100644 index 000000000..6cfc622be --- /dev/null +++ b/crates/wastlhw/src/component/resolve.rs @@ -0,0 +1,1010 @@ +use crate::component::*; +use crate::core; +use crate::kw; +use crate::names::Namespace; +use crate::token::Span; +use crate::token::{Id, Index}; +use crate::Error; + +/// Resolve the fields of a component and everything nested within it, changing +/// `Index::Id` to `Index::Num` and expanding alias syntax sugar. +pub fn resolve(component: &mut Component<'_>) -> Result<(), Error> { + let fields = match &mut component.kind { + ComponentKind::Text(fields) => fields, + ComponentKind::Binary(_) => return Ok(()), + }; + let mut resolver = Resolver::default(); + resolver.fields(component.id, fields) +} + +enum AnyAlias<'a> { + Core(CoreAlias<'a>), + Component(Alias<'a>), +} + +impl<'a> From> for ComponentField<'a> { + fn from(a: AnyAlias<'a>) -> Self { + match a { + AnyAlias::Core(a) => Self::CoreAlias(a), + AnyAlias::Component(a) => Self::Alias(a), + } + } +} + +impl<'a> From> for ModuleTypeDecl<'a> { + fn from(a: AnyAlias<'a>) -> Self { + match a { + AnyAlias::Core(a) => Self::Alias(a), + AnyAlias::Component(_) => unreachable!("should be core alias"), + } + } +} + +impl<'a> From> for ComponentTypeDecl<'a> { + fn from(a: AnyAlias<'a>) -> Self { + match a { + AnyAlias::Core(_) => unreachable!("should be component alias"), + AnyAlias::Component(a) => Self::Alias(a), + } + } +} + +impl<'a> From> for InstanceTypeDecl<'a> { + fn from(a: AnyAlias<'a>) -> Self { + match a { + AnyAlias::Core(_) => unreachable!("should be component alias"), + AnyAlias::Component(a) => Self::Alias(a), + } + } +} + +#[derive(Default)] +struct Resolver<'a> { + stack: Vec>, + + // When a name refers to a definition in an outer scope, we'll need to + // insert an outer alias before it. This collects the aliases to be + // inserted during resolution. + aliases_to_insert: Vec>, +} + +/// Context structure used to perform name resolution. +#[derive(Default)] +struct ComponentState<'a> { + id: Option>, + + // Namespaces within each component. Note that each namespace carries + // with it information about the signature of the item in that namespace. + // The signature is later used to synthesize the type of a component and + // inject type annotations if necessary. + core_funcs: Namespace<'a>, + core_globals: Namespace<'a>, + core_tables: Namespace<'a>, + core_memories: Namespace<'a>, + core_types: Namespace<'a>, + core_tags: Namespace<'a>, + core_instances: Namespace<'a>, + core_modules: Namespace<'a>, + + funcs: Namespace<'a>, + types: Namespace<'a>, + instances: Namespace<'a>, + components: Namespace<'a>, + values: Namespace<'a>, +} + +impl<'a> ComponentState<'a> { + fn new(id: Option>) -> ComponentState<'a> { + ComponentState { + id, + ..ComponentState::default() + } + } +} + +impl<'a> Resolver<'a> { + fn current(&mut self) -> &mut ComponentState<'a> { + self.stack + .last_mut() + .expect("should have at least one component state") + } + + fn fields( + &mut self, + id: Option>, + fields: &mut Vec>, + ) -> Result<(), Error> { + self.stack.push(ComponentState::new(id)); + self.resolve_prepending_aliases(fields, Resolver::field, ComponentState::register)?; + self.stack.pop(); + Ok(()) + } + + fn resolve_prepending_aliases( + &mut self, + fields: &mut Vec, + resolve: fn(&mut Self, &mut T) -> Result<(), Error>, + register: fn(&mut ComponentState<'a>, &T) -> Result<(), Error>, + ) -> Result<(), Error> + where + T: From>, + { + assert!(self.aliases_to_insert.is_empty()); + + // Iterate through the fields of the component. We use an index + // instead of an iterator because we'll be inserting aliases + // as we go. + let mut i = 0; + while i < fields.len() { + // Resolve names within the field. + resolve(self, &mut fields[i])?; + + // Name resolution may have emitted some aliases. Insert them before + // the current definition. + let amt = self.aliases_to_insert.len(); + fields.splice(i..i, self.aliases_to_insert.drain(..).map(T::from)); + i += amt; + + // Definitions can't refer to themselves or to definitions that appear + // later in the format. Now that we're done resolving this field, + // assign it an index for later definitions to refer to. + register(self.current(), &fields[i])?; + + i += 1; + } + + Ok(()) + } + + fn field(&mut self, field: &mut ComponentField<'a>) -> Result<(), Error> { + match field { + ComponentField::CoreModule(m) => self.core_module(m), + ComponentField::CoreInstance(i) => self.core_instance(i), + ComponentField::CoreAlias(a) => self.core_alias(a, false), + ComponentField::CoreType(t) => self.core_ty(t), + ComponentField::Component(c) => self.component(c), + ComponentField::Instance(i) => self.instance(i), + ComponentField::Alias(a) => self.alias(a), + ComponentField::Type(t) => self.ty(t), + ComponentField::CanonicalFunc(f) => self.canonical_func(f), + ComponentField::CoreFunc(_) => unreachable!("should be expanded already"), + ComponentField::Func(_) => unreachable!("should be expanded already"), + ComponentField::Start(s) => self.start(s), + ComponentField::Import(i) => self.item_sig(&mut i.item), + ComponentField::Export(e) => self.export(&mut e.kind), + ComponentField::Custom(_) => Ok(()), + } + } + + fn core_module(&mut self, module: &mut CoreModule) -> Result<(), Error> { + match &mut module.kind { + CoreModuleKind::Inline { fields } => { + crate::core::resolve::resolve(fields)?; + } + + CoreModuleKind::Import { .. } => { + unreachable!("should be expanded already") + } + } + + Ok(()) + } + + fn component(&mut self, component: &mut NestedComponent<'a>) -> Result<(), Error> { + match &mut component.kind { + NestedComponentKind::Import { .. } => unreachable!("should be expanded already"), + NestedComponentKind::Inline(fields) => self.fields(component.id, fields), + } + } + + fn core_instance(&mut self, instance: &mut CoreInstance<'a>) -> Result<(), Error> { + match &mut instance.kind { + CoreInstanceKind::Instantiate { module, args } => { + self.component_item_ref(module)?; + for arg in args { + match &mut arg.kind { + CoreInstantiationArgKind::Instance(i) => { + self.core_item_ref(i)?; + } + CoreInstantiationArgKind::BundleOfExports(..) => { + unreachable!("should be expanded already"); + } + } + } + } + CoreInstanceKind::BundleOfExports(exports) => { + for export in exports { + self.core_item_ref(&mut export.item)?; + } + } + } + Ok(()) + } + + fn instance(&mut self, instance: &mut Instance<'a>) -> Result<(), Error> { + match &mut instance.kind { + InstanceKind::Instantiate { component, args } => { + self.component_item_ref(component)?; + for arg in args { + match &mut arg.kind { + InstantiationArgKind::Item(e) => { + self.export(e)?; + } + InstantiationArgKind::BundleOfExports(..) => { + unreachable!("should be expanded already") + } + } + } + } + InstanceKind::BundleOfExports(exports) => { + for export in exports { + self.export(&mut export.kind)?; + } + } + InstanceKind::Import { .. } => { + unreachable!("should be expanded already") + } + } + Ok(()) + } + + fn item_sig(&mut self, item: &mut ItemSig<'a>) -> Result<(), Error> { + match &mut item.kind { + // Here we must be explicit otherwise the module type reference will + // be assumed to be in the component type namespace + ItemSigKind::CoreModule(t) => self.core_type_use(t), + ItemSigKind::Func(t) => self.component_type_use(t), + ItemSigKind::Component(t) => self.component_type_use(t), + ItemSigKind::Instance(t) => self.component_type_use(t), + ItemSigKind::Value(t) => self.component_val_type(&mut t.0), + ItemSigKind::Type(b) => match b { + TypeBounds::Eq(i) => self.resolve_ns(i, Ns::Type), + }, + } + } + + fn export(&mut self, kind: &mut ComponentExportKind<'a>) -> Result<(), Error> { + match kind { + // Here we do *not* have to be explicit as the item ref is to a core module + ComponentExportKind::CoreModule(r) => self.component_item_ref(r), + ComponentExportKind::Func(r) => self.component_item_ref(r), + ComponentExportKind::Value(r) => self.component_item_ref(r), + ComponentExportKind::Type(r) => self.component_item_ref(r), + ComponentExportKind::Component(r) => self.component_item_ref(r), + ComponentExportKind::Instance(r) => self.component_item_ref(r), + } + } + + fn start(&mut self, start: &mut Start<'a>) -> Result<(), Error> { + self.resolve_ns(&mut start.func, Ns::Func)?; + for arg in start.args.iter_mut() { + self.component_item_ref(arg)?; + } + Ok(()) + } + + fn outer_alias>( + &mut self, + outer: &mut Index<'a>, + index: &mut Index<'a>, + kind: T, + span: Span, + enclosing_only: bool, + ) -> Result<(), Error> { + // Short-circuit when both indices are already resolved as this + // helps to write tests for invalid modules where wasmparser should + // be the one returning the error. + if let Index::Num(..) = outer { + if let Index::Num(..) = index { + return Ok(()); + } + } + + // Resolve `outer`, and compute the depth at which to look up + // `index`. + let depth = match outer { + Index::Id(id) => { + let mut depth = 0; + for resolver in self.stack.iter().rev() { + if resolver.id == Some(*id) { + break; + } + depth += 1; + } + if depth as usize == self.stack.len() { + return Err(Error::new( + span, + format!("outer component `{}` not found", id.name()), + )); + } + depth + } + Index::Num(n, _span) => *n, + }; + + if depth as usize >= self.stack.len() { + return Err(Error::new( + span, + format!("outer count of `{}` is too large", depth), + )); + } + + if enclosing_only && depth > 1 { + return Err(Error::new( + span, + "only the local or enclosing scope can be aliased".to_string(), + )); + } + + *outer = Index::Num(depth, span); + + // Resolve `index` within the computed scope depth. + let computed = self.stack.len() - 1 - depth as usize; + self.stack[computed].resolve(kind.into(), index)?; + + Ok(()) + } + + fn core_alias(&mut self, alias: &mut CoreAlias<'a>, enclosing_only: bool) -> Result<(), Error> { + match &mut alias.target { + CoreAliasTarget::Export { + instance, + name: _, + kind: _, + } => self.resolve_ns(instance, Ns::CoreInstance), + CoreAliasTarget::Outer { outer, index, kind } => { + self.outer_alias(outer, index, *kind, alias.span, enclosing_only) + } + } + } + + fn alias(&mut self, alias: &mut Alias<'a>) -> Result<(), Error> { + match &mut alias.target { + AliasTarget::Export { + instance, + name: _, + kind: _, + } => self.resolve_ns(instance, Ns::Instance), + AliasTarget::Outer { outer, index, kind } => { + self.outer_alias(outer, index, *kind, alias.span, false) + } + } + } + + fn canonical_func(&mut self, func: &mut CanonicalFunc<'a>) -> Result<(), Error> { + let opts = match &mut func.kind { + CanonicalFuncKind::Lift { ty, info } => { + self.component_type_use(ty)?; + self.core_item_ref(&mut info.func)?; + &mut info.opts + } + CanonicalFuncKind::Lower(info) => { + self.component_item_ref(&mut info.func)?; + &mut info.opts + } + }; + + for opt in opts { + match opt { + CanonOpt::StringUtf8 | CanonOpt::StringUtf16 | CanonOpt::StringLatin1Utf16 => {} + CanonOpt::Memory(r) => self.core_item_ref(r)?, + CanonOpt::Realloc(r) | CanonOpt::PostReturn(r) => self.core_item_ref(r)?, + } + } + + Ok(()) + } + + fn core_type_use(&mut self, ty: &mut CoreTypeUse<'a, T>) -> Result<(), Error> { + let item = match ty { + CoreTypeUse::Ref(r) => r, + CoreTypeUse::Inline(_) => { + unreachable!("inline type-use should be expanded by now") + } + }; + self.core_item_ref(item) + } + + fn component_type_use(&mut self, ty: &mut ComponentTypeUse<'a, T>) -> Result<(), Error> { + let item = match ty { + ComponentTypeUse::Ref(r) => r, + ComponentTypeUse::Inline(_) => { + unreachable!("inline type-use should be expanded by now") + } + }; + self.component_item_ref(item) + } + + fn defined_type(&mut self, ty: &mut ComponentDefinedType<'a>) -> Result<(), Error> { + match ty { + ComponentDefinedType::Primitive(_) => {} + ComponentDefinedType::Flags(_) => {} + ComponentDefinedType::Enum(_) => {} + ComponentDefinedType::Record(r) => { + for field in r.fields.iter_mut() { + self.component_val_type(&mut field.ty)?; + } + } + ComponentDefinedType::Variant(v) => { + // Namespace for case identifier resolution + let mut ns = Namespace::default(); + for case in v.cases.iter_mut() { + let index = ns.register(case.id, "variant case")?; + + if let Some(ty) = &mut case.ty { + self.component_val_type(ty)?; + } + + if let Some(refines) = &mut case.refines { + if let Refinement::Index(span, idx) = refines { + let resolved = ns.resolve(idx, "variant case")?; + if resolved == index { + return Err(Error::new( + *span, + "variant case cannot refine itself".to_string(), + )); + } + + *refines = Refinement::Resolved(resolved); + } + } + } + } + ComponentDefinedType::List(l) => { + self.component_val_type(&mut *l.element)?; + } + ComponentDefinedType::Tuple(t) => { + for field in t.fields.iter_mut() { + self.component_val_type(field)?; + } + } + ComponentDefinedType::Union(t) => { + for ty in t.types.iter_mut() { + self.component_val_type(ty)?; + } + } + ComponentDefinedType::Option(o) => { + self.component_val_type(&mut *o.element)?; + } + ComponentDefinedType::Result(r) => { + if let Some(ty) = &mut r.ok { + self.component_val_type(ty)?; + } + + if let Some(ty) = &mut r.err { + self.component_val_type(ty)?; + } + } + } + Ok(()) + } + + fn component_val_type(&mut self, ty: &mut ComponentValType<'a>) -> Result<(), Error> { + match ty { + ComponentValType::Ref(idx) => self.resolve_ns(idx, Ns::Type), + ComponentValType::Inline(ComponentDefinedType::Primitive(_)) => Ok(()), + ComponentValType::Inline(_) => unreachable!("should be expanded by now"), + } + } + + fn core_ty(&mut self, field: &mut CoreType<'a>) -> Result<(), Error> { + match &mut field.def { + CoreTypeDef::Def(_) => {} + CoreTypeDef::Module(t) => { + self.stack.push(ComponentState::new(field.id)); + self.module_type(t)?; + self.stack.pop(); + } + } + Ok(()) + } + + fn ty(&mut self, field: &mut Type<'a>) -> Result<(), Error> { + match &mut field.def { + TypeDef::Defined(t) => { + self.defined_type(t)?; + } + TypeDef::Func(f) => { + for param in f.params.iter_mut() { + self.component_val_type(&mut param.ty)?; + } + + for result in f.results.iter_mut() { + self.component_val_type(&mut result.ty)?; + } + } + TypeDef::Component(c) => { + self.stack.push(ComponentState::new(field.id)); + self.component_type(c)?; + self.stack.pop(); + } + TypeDef::Instance(i) => { + self.stack.push(ComponentState::new(field.id)); + self.instance_type(i)?; + self.stack.pop(); + } + } + Ok(()) + } + + fn component_type(&mut self, c: &mut ComponentType<'a>) -> Result<(), Error> { + self.resolve_prepending_aliases( + &mut c.decls, + |resolver, decl| match decl { + ComponentTypeDecl::Alias(alias) => resolver.alias(alias), + ComponentTypeDecl::CoreType(ty) => resolver.core_ty(ty), + ComponentTypeDecl::Type(ty) => resolver.ty(ty), + ComponentTypeDecl::Import(import) => resolver.item_sig(&mut import.item), + ComponentTypeDecl::Export(export) => resolver.item_sig(&mut export.item), + }, + |state, decl| { + match decl { + ComponentTypeDecl::Alias(alias) => { + state.register_alias(alias)?; + } + ComponentTypeDecl::CoreType(ty) => { + state.core_types.register(ty.id, "core type")?; + } + ComponentTypeDecl::Type(ty) => { + state.types.register(ty.id, "type")?; + } + // Only the type namespace is populated within the component type + // namespace so these are ignored here. + ComponentTypeDecl::Import(_) | ComponentTypeDecl::Export(_) => {} + } + Ok(()) + }, + ) + } + + fn instance_type(&mut self, c: &mut InstanceType<'a>) -> Result<(), Error> { + self.resolve_prepending_aliases( + &mut c.decls, + |resolver, decl| match decl { + InstanceTypeDecl::Alias(alias) => resolver.alias(alias), + InstanceTypeDecl::CoreType(ty) => resolver.core_ty(ty), + InstanceTypeDecl::Type(ty) => resolver.ty(ty), + InstanceTypeDecl::Export(export) => resolver.item_sig(&mut export.item), + }, + |state, decl| { + match decl { + InstanceTypeDecl::Alias(alias) => { + state.register_alias(alias)?; + } + InstanceTypeDecl::CoreType(ty) => { + state.core_types.register(ty.id, "core type")?; + } + InstanceTypeDecl::Type(ty) => { + state.types.register(ty.id, "type")?; + } + InstanceTypeDecl::Export(_export) => {} + } + Ok(()) + }, + ) + } + + fn core_item_ref(&mut self, item: &mut CoreItemRef<'a, K>) -> Result<(), Error> + where + K: CoreItem + Copy, + { + // Check for not being an instance export reference + if item.export_name.is_none() { + self.resolve_ns(&mut item.idx, item.kind.ns())?; + return Ok(()); + } + + // This is a reference to a core instance export + let mut index = item.idx; + self.resolve_ns(&mut index, Ns::CoreInstance)?; + + // Record an alias to reference the export + let span = item.idx.span(); + let alias = CoreAlias { + span, + id: None, + name: None, + target: CoreAliasTarget::Export { + instance: index, + name: item.export_name.unwrap(), + kind: item.kind.ns().into(), + }, + }; + + index = Index::Num(self.current().register_core_alias(&alias)?, span); + self.aliases_to_insert.push(AnyAlias::Core(alias)); + + item.idx = index; + item.export_name = None; + + Ok(()) + } + + fn component_item_ref(&mut self, item: &mut ItemRef<'a, K>) -> Result<(), Error> + where + K: ComponentItem + Copy, + { + // Check for not being an instance export reference + if item.export_names.is_empty() { + self.resolve_ns(&mut item.idx, item.kind.ns())?; + return Ok(()); + } + + // This is a reference to an instance export + let mut index = item.idx; + self.resolve_ns(&mut index, Ns::Instance)?; + + let span = item.idx.span(); + for (pos, export_name) in item.export_names.iter().enumerate() { + // Record an alias to reference the export + let alias = Alias { + span, + id: None, + name: None, + target: AliasTarget::Export { + instance: index, + name: export_name, + kind: if pos == item.export_names.len() - 1 { + item.kind.ns().into() + } else { + ComponentExportAliasKind::Instance + }, + }, + }; + + index = Index::Num(self.current().register_alias(&alias)?, span); + self.aliases_to_insert.push(AnyAlias::Component(alias)); + } + + item.idx = index; + item.export_names = Vec::new(); + + Ok(()) + } + + fn resolve_ns(&mut self, idx: &mut Index<'a>, ns: Ns) -> Result<(), Error> { + // Perform resolution on a local clone walking up the stack of components + // that we have. Note that a local clone is used since we don't want to use + // the parent's resolved index if a parent matches, instead we want to use + // the index of the alias that we will automatically insert. + let mut idx_clone = *idx; + for (depth, resolver) in self.stack.iter_mut().rev().enumerate() { + let depth = depth as u32; + let found = match resolver.resolve(ns, &mut idx_clone) { + Ok(idx) => idx, + // Try the next parent + Err(_) => continue, + }; + + // If this is the current component then no extra alias is necessary, so + // return success. + if depth == 0 { + *idx = idx_clone; + return Ok(()); + } + let id = match idx { + Index::Id(id) => *id, + Index::Num(..) => unreachable!(), + }; + + // When resolution succeeds in a parent then an outer alias is + // automatically inserted here in this component. + let span = idx.span(); + let alias = Alias { + span, + id: Some(id), + name: None, + target: AliasTarget::Outer { + outer: Index::Num(depth, span), + index: Index::Num(found, span), + kind: ns.into(), + }, + }; + let local_index = self.current().register_alias(&alias)?; + self.aliases_to_insert.push(AnyAlias::Component(alias)); + *idx = Index::Num(local_index, span); + return Ok(()); + } + + // If resolution in any parent failed then simply return the error from our + // local namespace + self.current().resolve(ns, idx)?; + unreachable!() + } + + fn module_type(&mut self, ty: &mut ModuleType<'a>) -> Result<(), Error> { + return self.resolve_prepending_aliases( + &mut ty.decls, + |resolver, decl| match decl { + ModuleTypeDecl::Alias(alias) => resolver.core_alias(alias, true), + ModuleTypeDecl::Type(_) => Ok(()), + ModuleTypeDecl::Import(import) => resolve_item_sig(resolver, &mut import.item), + ModuleTypeDecl::Export(_, item) => resolve_item_sig(resolver, item), + }, + |state, decl| { + match decl { + ModuleTypeDecl::Alias(alias) => { + state.register_core_alias(alias)?; + } + ModuleTypeDecl::Type(ty) => { + state.core_types.register(ty.id, "type")?; + } + // Only the type namespace is populated within the module type + // namespace so these are ignored here. + ModuleTypeDecl::Import(_) | ModuleTypeDecl::Export(..) => {} + } + Ok(()) + }, + ); + + fn resolve_item_sig<'a>( + resolver: &Resolver<'a>, + sig: &mut core::ItemSig<'a>, + ) -> Result<(), Error> { + match &mut sig.kind { + core::ItemKind::Func(ty) | core::ItemKind::Tag(core::TagType::Exception(ty)) => { + let idx = ty.index.as_mut().expect("index should be filled in"); + resolver + .stack + .last() + .unwrap() + .core_types + .resolve(idx, "type")?; + } + core::ItemKind::Memory(_) + | core::ItemKind::Global(_) + | core::ItemKind::Table(_) => {} + } + Ok(()) + } + } +} + +impl<'a> ComponentState<'a> { + fn resolve(&mut self, ns: Ns, idx: &mut Index<'a>) -> Result { + match ns { + Ns::CoreFunc => self.core_funcs.resolve(idx, "core func"), + Ns::CoreGlobal => self.core_globals.resolve(idx, "core global"), + Ns::CoreTable => self.core_tables.resolve(idx, "core table"), + Ns::CoreMemory => self.core_memories.resolve(idx, "core memory"), + Ns::CoreType => self.core_types.resolve(idx, "core type"), + Ns::CoreTag => self.core_tags.resolve(idx, "core tag"), + Ns::CoreInstance => self.core_instances.resolve(idx, "core instance"), + Ns::CoreModule => self.core_modules.resolve(idx, "core module"), + Ns::Func => self.funcs.resolve(idx, "func"), + Ns::Type => self.types.resolve(idx, "type"), + Ns::Instance => self.instances.resolve(idx, "instance"), + Ns::Component => self.components.resolve(idx, "component"), + Ns::Value => self.values.resolve(idx, "value"), + } + } + + /// Assign an index to the given field. + fn register(&mut self, item: &ComponentField<'a>) -> Result<(), Error> { + match item { + ComponentField::CoreModule(m) => self.core_modules.register(m.id, "core module")?, + ComponentField::CoreInstance(i) => { + self.core_instances.register(i.id, "core instance")? + } + ComponentField::CoreAlias(a) => self.register_core_alias(a)?, + ComponentField::CoreType(t) => self.core_types.register(t.id, "core type")?, + ComponentField::Component(c) => self.components.register(c.id, "component")?, + ComponentField::Instance(i) => self.instances.register(i.id, "instance")?, + ComponentField::Alias(a) => self.register_alias(a)?, + ComponentField::Type(t) => self.types.register(t.id, "type")?, + ComponentField::CanonicalFunc(f) => match &f.kind { + CanonicalFuncKind::Lift { .. } => self.funcs.register(f.id, "func")?, + CanonicalFuncKind::Lower(_) => self.core_funcs.register(f.id, "core func")?, + }, + ComponentField::CoreFunc(_) | ComponentField::Func(_) => { + unreachable!("should be expanded already") + } + ComponentField::Start(s) => self.values.register(s.result, "value")?, + ComponentField::Import(i) => match &i.item.kind { + ItemSigKind::CoreModule(_) => { + self.core_modules.register(i.item.id, "core module")? + } + ItemSigKind::Func(_) => self.funcs.register(i.item.id, "func")?, + ItemSigKind::Component(_) => self.components.register(i.item.id, "component")?, + ItemSigKind::Instance(_) => self.instances.register(i.item.id, "instance")?, + ItemSigKind::Value(_) => self.values.register(i.item.id, "value")?, + ItemSigKind::Type(_) => self.types.register(i.item.id, "type")?, + }, + ComponentField::Export(_) | ComponentField::Custom(_) => { + // Exports and custom sections don't define any items + return Ok(()); + } + }; + + Ok(()) + } + + fn register_alias(&mut self, alias: &Alias<'a>) -> Result { + match alias.target { + AliasTarget::Export { + kind: ComponentExportAliasKind::Component, + .. + } + | AliasTarget::Outer { + kind: ComponentOuterAliasKind::Component, + .. + } => self.components.register(alias.id, "component"), + AliasTarget::Export { + kind: ComponentExportAliasKind::CoreModule, + .. + } + | AliasTarget::Outer { + kind: ComponentOuterAliasKind::CoreModule, + .. + } => self.core_modules.register(alias.id, "core module"), + AliasTarget::Export { + kind: ComponentExportAliasKind::Type, + .. + } + | AliasTarget::Outer { + kind: ComponentOuterAliasKind::Type, + .. + } => self.types.register(alias.id, "type"), + AliasTarget::Outer { + kind: ComponentOuterAliasKind::CoreType, + .. + } => self.core_types.register(alias.id, "core type"), + AliasTarget::Export { + kind: ComponentExportAliasKind::Func, + .. + } => self.funcs.register(alias.id, "func"), + AliasTarget::Export { + kind: ComponentExportAliasKind::Value, + .. + } => self.values.register(alias.id, "value"), + AliasTarget::Export { + kind: ComponentExportAliasKind::Instance, + .. + } => self.instances.register(alias.id, "instance"), + } + } + + fn register_core_alias(&mut self, alias: &CoreAlias<'a>) -> Result { + match alias.target { + CoreAliasTarget::Export { kind, .. } => match kind { + core::ExportKind::Func => self.core_funcs.register(alias.id, "core func"), + core::ExportKind::Table => self.core_tables.register(alias.id, "core table"), + core::ExportKind::Memory => self.core_memories.register(alias.id, "core memory"), + core::ExportKind::Global => self.core_globals.register(alias.id, "core global"), + core::ExportKind::Tag => self.core_tags.register(alias.id, "core tag"), + }, + CoreAliasTarget::Outer { + outer: _, + index: _, + kind: CoreOuterAliasKind::Type, + } => self.core_types.register(alias.id, "core type"), + } + } +} + +#[derive(PartialEq, Eq, Hash, Copy, Clone, Debug)] +enum Ns { + CoreFunc, + CoreGlobal, + CoreTable, + CoreMemory, + CoreType, + CoreTag, + CoreInstance, + CoreModule, + Func, + Type, + Instance, + Component, + Value, +} + +trait ComponentItem { + fn ns(&self) -> Ns; +} + +trait CoreItem { + fn ns(&self) -> Ns; +} + +macro_rules! component_item { + ($kw:path, $kind:ident) => { + impl ComponentItem for $kw { + fn ns(&self) -> Ns { + Ns::$kind + } + } + }; +} + +macro_rules! core_item { + ($kw:path, $kind:ident) => { + impl CoreItem for $kw { + fn ns(&self) -> Ns { + Ns::$kind + } + } + }; +} + +component_item!(kw::func, Func); +component_item!(kw::r#type, Type); +component_item!(kw::r#instance, Instance); +component_item!(kw::component, Component); +component_item!(kw::value, Value); +component_item!(kw::module, CoreModule); + +core_item!(kw::func, CoreFunc); +core_item!(kw::memory, CoreMemory); +core_item!(kw::r#type, CoreType); +core_item!(kw::r#instance, CoreInstance); + +impl From for ComponentExportAliasKind { + fn from(ns: Ns) -> Self { + match ns { + Ns::CoreModule => Self::CoreModule, + Ns::Func => Self::Func, + Ns::Type => Self::Type, + Ns::Instance => Self::Instance, + Ns::Component => Self::Component, + Ns::Value => Self::Value, + _ => unreachable!("not a component exportable namespace"), + } + } +} + +impl From for ComponentOuterAliasKind { + fn from(ns: Ns) -> Self { + match ns { + Ns::CoreModule => Self::CoreModule, + Ns::CoreType => Self::CoreType, + Ns::Type => Self::Type, + Ns::Component => Self::Component, + _ => unreachable!("not an outer alias namespace"), + } + } +} + +impl From for core::ExportKind { + fn from(ns: Ns) -> Self { + match ns { + Ns::CoreFunc => Self::Func, + Ns::CoreTable => Self::Table, + Ns::CoreGlobal => Self::Global, + Ns::CoreMemory => Self::Memory, + Ns::CoreTag => Self::Tag, + _ => unreachable!("not a core exportable namespace"), + } + } +} + +impl From for Ns { + fn from(kind: ComponentOuterAliasKind) -> Self { + match kind { + ComponentOuterAliasKind::CoreModule => Self::CoreModule, + ComponentOuterAliasKind::CoreType => Self::CoreType, + ComponentOuterAliasKind::Type => Self::Type, + ComponentOuterAliasKind::Component => Self::Component, + } + } +} + +impl From for Ns { + fn from(kind: CoreOuterAliasKind) -> Self { + match kind { + CoreOuterAliasKind::Type => Self::CoreType, + } + } +} + +impl CoreItem for core::ExportKind { + fn ns(&self) -> Ns { + match self { + Self::Func => Ns::CoreFunc, + Self::Table => Ns::CoreTable, + Self::Global => Ns::CoreGlobal, + Self::Memory => Ns::CoreMemory, + Self::Tag => Ns::CoreTag, + } + } +} diff --git a/crates/wastlhw/src/component/types.rs b/crates/wastlhw/src/component/types.rs new file mode 100644 index 000000000..1024cb044 --- /dev/null +++ b/crates/wastlhw/src/component/types.rs @@ -0,0 +1,953 @@ +use crate::component::*; +use crate::core; +use crate::kw; +use crate::parser::Lookahead1; +use crate::parser::Peek; +use crate::parser::{Parse, Parser, Result}; +use crate::token::Index; +use crate::token::LParen; +use crate::token::{Id, NameAnnotation, Span}; + +/// A core type declaration. +#[derive(Debug)] +pub struct CoreType<'a> { + /// Where this type was defined. + pub span: Span, + /// An optional identifier to refer to this `core type` by as part of name + /// resolution. + pub id: Option>, + /// An optional name for this type stored in the custom `name` section. + pub name: Option>, + /// The core type's definition. + pub def: CoreTypeDef<'a>, +} + +impl<'a> Parse<'a> for CoreType<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + parser.parse::()?; + let id = parser.parse()?; + let name = parser.parse()?; + let def = parser.parens(|p| p.parse())?; + + Ok(Self { + span, + id, + name, + def, + }) + } +} + +/// Represents a core type definition. +/// +/// In the future this may be removed when module types are a part of +/// a core module. +#[derive(Debug)] +pub enum CoreTypeDef<'a> { + /// The type definition is one of the core types. + Def(core::TypeDef<'a>), + /// The type definition is a module type. + Module(ModuleType<'a>), +} + +impl<'a> Parse<'a> for CoreTypeDef<'a> { + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::() { + parser.parse::()?; + Ok(Self::Module(parser.parse()?)) + } else { + Ok(Self::Def(parser.parse()?)) + } + } +} + +/// A type definition for a core module. +#[derive(Debug)] +pub struct ModuleType<'a> { + /// The declarations of the module type. + pub decls: Vec>, +} + +impl<'a> Parse<'a> for ModuleType<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.depth_check()?; + Ok(Self { + decls: parser.parse()?, + }) + } +} + +/// The declarations of a [`ModuleType`]. +#[derive(Debug)] +pub enum ModuleTypeDecl<'a> { + /// A core type. + Type(core::Type<'a>), + /// An alias local to the module type. + Alias(CoreAlias<'a>), + /// An import. + Import(core::Import<'a>), + /// An export. + Export(&'a str, core::ItemSig<'a>), +} + +impl<'a> Parse<'a> for ModuleTypeDecl<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + Ok(Self::Type(parser.parse()?)) + } else if l.peek::() { + let span = parser.parse::()?.0; + Ok(Self::Alias(CoreAlias::parse_outer_type_alias( + span, parser, + )?)) + } else if l.peek::() { + Ok(Self::Import(parser.parse()?)) + } else if l.peek::() { + parser.parse::()?; + let name = parser.parse()?; + let et = parser.parens(|parser| parser.parse())?; + Ok(Self::Export(name, et)) + } else { + Err(l.error()) + } + } +} + +impl<'a> Parse<'a> for Vec> { + fn parse(parser: Parser<'a>) -> Result { + let mut decls = Vec::new(); + while !parser.is_empty() { + decls.push(parser.parens(|parser| parser.parse())?); + } + Ok(decls) + } +} + +/// A type declaration in a component. +#[derive(Debug)] +pub struct Type<'a> { + /// Where this type was defined. + pub span: Span, + /// An optional identifier to refer to this `type` by as part of name + /// resolution. + pub id: Option>, + /// An optional name for this type stored in the custom `name` section. + pub name: Option>, + /// If present, inline export annotations which indicate names this + /// definition should be exported under. + pub exports: core::InlineExport<'a>, + /// The type definition. + pub def: TypeDef<'a>, +} + +impl<'a> Parse<'a> for Type<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let id = parser.parse()?; + let name = parser.parse()?; + let exports = parser.parse()?; + let def = parser.parse()?; + + Ok(Self { + span, + id, + name, + exports, + def, + }) + } +} + +/// A definition of a component type. +#[derive(Debug)] +pub enum TypeDef<'a> { + /// A defined value type. + Defined(ComponentDefinedType<'a>), + /// A component function type. + Func(ComponentFunctionType<'a>), + /// A component type. + Component(ComponentType<'a>), + /// An instance type. + Instance(InstanceType<'a>), +} + +impl<'a> Parse<'a> for TypeDef<'a> { + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::() { + parser.parens(|parser| { + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + Ok(Self::Func(parser.parse()?)) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::Component(parser.parse()?)) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::Instance(parser.parse()?)) + } else { + Ok(Self::Defined(ComponentDefinedType::parse_non_primitive( + parser, l, + )?)) + } + }) + } else { + // Only primitive types have no parens + Ok(Self::Defined(ComponentDefinedType::Primitive( + parser.parse()?, + ))) + } + } +} + +/// A primitive value type. +#[allow(missing_docs)] +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum PrimitiveValType { + Bool, + S8, + U8, + S16, + U16, + S32, + U32, + S64, + U64, + Float32, + Float64, + Char, + String, +} + +impl<'a> Parse<'a> for PrimitiveValType { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + Ok(Self::Bool) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::S8) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::U8) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::S16) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::U16) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::S32) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::U32) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::S64) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::U64) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::Float32) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::Float64) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::Char) + } else if l.peek::() { + parser.parse::()?; + Ok(Self::String) + } else { + Err(l.error()) + } + } +} + +impl Peek for PrimitiveValType { + fn peek(cursor: crate::parser::Cursor<'_>) -> bool { + matches!( + cursor.keyword(), + Some(("bool", _)) + | Some(("s8", _)) + | Some(("u8", _)) + | Some(("s16", _)) + | Some(("u16", _)) + | Some(("s32", _)) + | Some(("u32", _)) + | Some(("s64", _)) + | Some(("u64", _)) + | Some(("float32", _)) + | Some(("float64", _)) + | Some(("char", _)) + | Some(("string", _)) + ) + } + + fn display() -> &'static str { + "primitive value type" + } +} + +/// A component value type. +#[allow(missing_docs)] +#[derive(Debug)] +pub enum ComponentValType<'a> { + /// The value type is an inline defined type. + Inline(ComponentDefinedType<'a>), + /// The value type is an index reference to a defined type. + Ref(Index<'a>), +} + +impl<'a> Parse<'a> for ComponentValType<'a> { + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::>() { + Ok(Self::Ref(parser.parse()?)) + } else { + Ok(Self::Inline(InlineComponentValType::parse(parser)?.0)) + } + } +} + +impl Peek for ComponentValType<'_> { + fn peek(cursor: crate::parser::Cursor<'_>) -> bool { + Index::peek(cursor) || ComponentDefinedType::peek(cursor) + } + + fn display() -> &'static str { + "component value type" + } +} + +/// An inline-only component value type. +/// +/// This variation does not parse type indexes. +#[allow(missing_docs)] +#[derive(Debug)] +pub struct InlineComponentValType<'a>(ComponentDefinedType<'a>); + +impl<'a> Parse<'a> for InlineComponentValType<'a> { + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::() { + parser.parens(|parser| { + Ok(Self(ComponentDefinedType::parse_non_primitive( + parser, + parser.lookahead1(), + )?)) + }) + } else { + Ok(Self(ComponentDefinedType::Primitive(parser.parse()?))) + } + } +} + +// A component defined type. +#[allow(missing_docs)] +#[derive(Debug)] +pub enum ComponentDefinedType<'a> { + Primitive(PrimitiveValType), + Record(Record<'a>), + Variant(Variant<'a>), + List(List<'a>), + Tuple(Tuple<'a>), + Flags(Flags<'a>), + Enum(Enum<'a>), + Union(Union<'a>), + Option(OptionType<'a>), + Result(ResultType<'a>), +} + +impl<'a> ComponentDefinedType<'a> { + fn parse_non_primitive(parser: Parser<'a>, mut l: Lookahead1<'a>) -> Result { + parser.depth_check()?; + if l.peek::() { + Ok(Self::Record(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Variant(parser.parse()?)) + } else if l.peek::() { + Ok(Self::List(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Tuple(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Flags(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Enum(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Union(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Option(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Result(parser.parse()?)) + } else { + Err(l.error()) + } + } +} + +impl Default for ComponentDefinedType<'_> { + fn default() -> Self { + Self::Primitive(PrimitiveValType::Bool) + } +} + +impl Peek for ComponentDefinedType<'_> { + fn peek(cursor: crate::parser::Cursor<'_>) -> bool { + if PrimitiveValType::peek(cursor) { + return true; + } + + match cursor.lparen() { + Some(cursor) => matches!( + cursor.keyword(), + Some(("record", _)) + | Some(("variant", _)) + | Some(("list", _)) + | Some(("tuple", _)) + | Some(("flags", _)) + | Some(("enum", _)) + | Some(("union", _)) + | Some(("option", _)) + | Some(("result", _)) + ), + None => false, + } + } + + fn display() -> &'static str { + "component defined type" + } +} + +/// A record defined type. +#[derive(Debug)] +pub struct Record<'a> { + /// The fields of the record. + pub fields: Vec>, +} + +impl<'a> Parse<'a> for Record<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + let mut fields = Vec::new(); + while !parser.is_empty() { + fields.push(parser.parens(|p| p.parse())?); + } + Ok(Self { fields }) + } +} + +/// A record type field. +#[derive(Debug)] +pub struct RecordField<'a> { + /// The name of the field. + pub name: &'a str, + /// The type of the field. + pub ty: ComponentValType<'a>, +} + +impl<'a> Parse<'a> for RecordField<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + Ok(Self { + name: parser.parse()?, + ty: parser.parse()?, + }) + } +} + +/// A variant defined type. +#[derive(Debug)] +pub struct Variant<'a> { + /// The cases of the variant type. + pub cases: Vec>, +} + +impl<'a> Parse<'a> for Variant<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + let mut cases = Vec::new(); + while !parser.is_empty() { + cases.push(parser.parens(|p| p.parse())?); + } + Ok(Self { cases }) + } +} + +/// A case of a variant type. +#[derive(Debug)] +pub struct VariantCase<'a> { + /// Where this `case` was defined + pub span: Span, + /// An optional identifier to refer to this case by as part of name + /// resolution. + pub id: Option>, + /// The name of the case. + pub name: &'a str, + /// The optional type of the case. + pub ty: Option>, + /// The optional refinement. + pub refines: Option>, +} + +impl<'a> Parse<'a> for VariantCase<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let id = parser.parse()?; + let name = parser.parse()?; + let ty = parser.parse()?; + let refines = if !parser.is_empty() { + Some(parser.parse()?) + } else { + None + }; + Ok(Self { + span, + id, + name, + ty, + refines, + }) + } +} + +/// A refinement for a variant case. +#[derive(Debug)] +pub enum Refinement<'a> { + /// The refinement is referenced by index. + Index(Span, Index<'a>), + /// The refinement has been resolved to an index into + /// the cases of the variant. + Resolved(u32), +} + +impl<'a> Parse<'a> for Refinement<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parens(|parser| { + let span = parser.parse::()?.0; + let id = parser.parse()?; + Ok(Self::Index(span, id)) + }) + } +} + +/// A list type. +#[derive(Debug)] +pub struct List<'a> { + /// The element type of the array. + pub element: Box>, +} + +impl<'a> Parse<'a> for List<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + Ok(Self { + element: Box::new(parser.parse()?), + }) + } +} + +/// A tuple type. +#[derive(Debug)] +pub struct Tuple<'a> { + /// The types of the fields of the tuple. + pub fields: Vec>, +} + +impl<'a> Parse<'a> for Tuple<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + let mut fields = Vec::new(); + while !parser.is_empty() { + fields.push(parser.parse()?); + } + Ok(Self { fields }) + } +} + +/// A flags type. +#[derive(Debug)] +pub struct Flags<'a> { + /// The names of the individual flags. + pub names: Vec<&'a str>, +} + +impl<'a> Parse<'a> for Flags<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + let mut names = Vec::new(); + while !parser.is_empty() { + names.push(parser.parse()?); + } + Ok(Self { names }) + } +} + +/// An enum type. +#[derive(Debug)] +pub struct Enum<'a> { + /// The tag names of the enum. + pub names: Vec<&'a str>, +} + +impl<'a> Parse<'a> for Enum<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + let mut names = Vec::new(); + while !parser.is_empty() { + names.push(parser.parse()?); + } + Ok(Self { names }) + } +} + +/// A union type. +#[derive(Debug)] +pub struct Union<'a> { + /// The types of the union. + pub types: Vec>, +} + +impl<'a> Parse<'a> for Union<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + let mut types = Vec::new(); + while !parser.is_empty() { + types.push(parser.parse()?); + } + Ok(Self { types }) + } +} + +/// An optional type. +#[derive(Debug)] +pub struct OptionType<'a> { + /// The type of the value, when a value is present. + pub element: Box>, +} + +impl<'a> Parse<'a> for OptionType<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + Ok(Self { + element: Box::new(parser.parse()?), + }) + } +} + +/// A result type. +#[derive(Debug)] +pub struct ResultType<'a> { + /// The type on success. + pub ok: Option>>, + /// The type on failure. + pub err: Option>>, +} + +impl<'a> Parse<'a> for ResultType<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + + let ok: Option = parser.parse()?; + let err: Option = if parser.peek::() { + Some(parser.parens(|parser| { + parser.parse::()?; + parser.parse() + })?) + } else { + None + }; + + Ok(Self { + ok: ok.map(Box::new), + err: err.map(Box::new), + }) + } +} + +/// A component function type with parameters and result. +#[derive(Debug)] +pub struct ComponentFunctionType<'a> { + /// The parameters of a function, optionally each having an identifier for + /// name resolution and a name for the custom `name` section. + pub params: Box<[ComponentFunctionParam<'a>]>, + /// The result of a function, optionally each having an identifier for + /// name resolution and a name for the custom `name` section. + pub results: Box<[ComponentFunctionResult<'a>]>, +} + +impl<'a> Parse<'a> for ComponentFunctionType<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut params: Vec = Vec::new(); + while parser.peek2::() { + params.push(parser.parens(|p| p.parse())?); + } + + let mut results: Vec = Vec::new(); + while parser.peek2::() { + results.push(parser.parens(|p| p.parse())?); + } + + Ok(Self { + params: params.into(), + results: results.into(), + }) + } +} + +/// A parameter of a [`ComponentFunctionType`]. +#[derive(Debug)] +pub struct ComponentFunctionParam<'a> { + /// An optionally-specified name of this parameter + pub name: Option<&'a str>, + /// The type of the parameter. + pub ty: ComponentValType<'a>, +} + +impl<'a> Parse<'a> for ComponentFunctionParam<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + Ok(Self { + name: parser.parse()?, + ty: parser.parse()?, + }) + } +} + +/// A result of a [`ComponentFunctionType`]. +#[derive(Debug)] +pub struct ComponentFunctionResult<'a> { + /// An optionally-specified name of this result + pub name: Option<&'a str>, + /// The type of the result. + pub ty: ComponentValType<'a>, +} + +impl<'a> Parse<'a> for ComponentFunctionResult<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + Ok(Self { + name: parser.parse()?, + ty: parser.parse()?, + }) + } +} + +/// The type of an exported item from an component or instance type. +#[derive(Debug)] +pub struct ComponentExportType<'a> { + /// Where this export was defined. + pub span: Span, + /// The name of this export. + pub name: &'a str, + /// The signature of the item. + pub item: ItemSig<'a>, +} + +impl<'a> Parse<'a> for ComponentExportType<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let name = parser.parse()?; + let item = parser.parens(|p| p.parse())?; + Ok(Self { span, name, item }) + } +} + +/// A type definition for a component type. +#[derive(Debug, Default)] +pub struct ComponentType<'a> { + /// The declarations of the component type. + pub decls: Vec>, +} + +impl<'a> Parse<'a> for ComponentType<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.depth_check()?; + Ok(Self { + decls: parser.parse()?, + }) + } +} + +/// A declaration of a component type. +#[derive(Debug)] +pub enum ComponentTypeDecl<'a> { + /// A core type definition local to the component type. + CoreType(CoreType<'a>), + /// A type definition local to the component type. + Type(Type<'a>), + /// An alias local to the component type. + Alias(Alias<'a>), + /// An import of the component type. + Import(ComponentImport<'a>), + /// An export of the component type. + Export(ComponentExportType<'a>), +} + +impl<'a> Parse<'a> for ComponentTypeDecl<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + Ok(Self::CoreType(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Type(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Alias(Alias::parse_outer_type_alias(parser)?)) + } else if l.peek::() { + Ok(Self::Import(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Export(parser.parse()?)) + } else { + Err(l.error()) + } + } +} + +impl<'a> Parse<'a> for Vec> { + fn parse(parser: Parser<'a>) -> Result { + let mut decls = Vec::new(); + while !parser.is_empty() { + decls.push(parser.parens(|parser| parser.parse())?); + } + Ok(decls) + } +} + +/// A type definition for an instance type. +#[derive(Debug)] +pub struct InstanceType<'a> { + /// The declarations of the instance type. + pub decls: Vec>, +} + +impl<'a> Parse<'a> for InstanceType<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.depth_check()?; + Ok(Self { + decls: parser.parse()?, + }) + } +} + +/// A declaration of an instance type. +#[derive(Debug)] +pub enum InstanceTypeDecl<'a> { + /// A core type definition local to the component type. + CoreType(CoreType<'a>), + /// A type definition local to the instance type. + Type(Type<'a>), + /// An alias local to the instance type. + Alias(Alias<'a>), + /// An export of the instance type. + Export(ComponentExportType<'a>), +} + +impl<'a> Parse<'a> for InstanceTypeDecl<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + Ok(Self::CoreType(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Type(parser.parse()?)) + } else if l.peek::() { + Ok(Self::Alias(Alias::parse_outer_type_alias(parser)?)) + } else if l.peek::() { + Ok(Self::Export(parser.parse()?)) + } else { + Err(l.error()) + } + } +} + +impl<'a> Parse<'a> for Vec> { + fn parse(parser: Parser<'a>) -> Result { + let mut decls = Vec::new(); + while !parser.is_empty() { + decls.push(parser.parens(|parser| parser.parse())?); + } + Ok(decls) + } +} + +/// A value type declaration used for values in import signatures. +#[derive(Debug)] +pub struct ComponentValTypeUse<'a>(pub ComponentValType<'a>); + +impl<'a> Parse<'a> for ComponentValTypeUse<'a> { + fn parse(parser: Parser<'a>) -> Result { + match ComponentTypeUse::<'a, InlineComponentValType<'a>>::parse(parser)? { + ComponentTypeUse::Ref(i) => Ok(Self(ComponentValType::Ref(i.idx))), + ComponentTypeUse::Inline(t) => Ok(Self(ComponentValType::Inline(t.0))), + } + } +} + +/// A reference to a core type defined in this component. +/// +/// This is the same as `TypeUse`, but accepts `$T` as shorthand for +/// `(type $T)`. +#[derive(Debug, Clone)] +pub enum CoreTypeUse<'a, T> { + /// The type that we're referencing. + Ref(CoreItemRef<'a, kw::r#type>), + /// The inline type. + Inline(T), +} + +impl<'a, T: Parse<'a>> Parse<'a> for CoreTypeUse<'a, T> { + fn parse(parser: Parser<'a>) -> Result { + // Here the core context is assumed, so no core prefix is expected + if parser.peek::() && parser.peek2::>() { + Ok(Self::Ref(parser.parens(|parser| parser.parse())?)) + } else { + Ok(Self::Inline(parser.parse()?)) + } + } +} + +impl Default for CoreTypeUse<'_, T> { + fn default() -> Self { + let span = Span::from_offset(0); + Self::Ref(CoreItemRef { + idx: Index::Num(0, span), + kind: kw::r#type(span), + export_name: None, + }) + } +} + +/// A reference to a type defined in this component. +/// +/// This is the same as `TypeUse`, but accepts `$T` as shorthand for +/// `(type $T)`. +#[derive(Debug, Clone)] +pub enum ComponentTypeUse<'a, T> { + /// The type that we're referencing. + Ref(ItemRef<'a, kw::r#type>), + /// The inline type. + Inline(T), +} + +impl<'a, T: Parse<'a>> Parse<'a> for ComponentTypeUse<'a, T> { + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::() && parser.peek2::>() { + Ok(Self::Ref(parser.parens(|parser| parser.parse())?)) + } else { + Ok(Self::Inline(parser.parse()?)) + } + } +} + +impl Default for ComponentTypeUse<'_, T> { + fn default() -> Self { + let span = Span::from_offset(0); + Self::Ref(ItemRef { + idx: Index::Num(0, span), + kind: kw::r#type(span), + export_names: Vec::new(), + }) + } +} diff --git a/crates/wastlhw/src/component/wast.rs b/crates/wastlhw/src/component/wast.rs new file mode 100644 index 000000000..b7a4a5d32 --- /dev/null +++ b/crates/wastlhw/src/component/wast.rs @@ -0,0 +1,163 @@ +use crate::kw; +use crate::parser::{Cursor, Parse, Parser, Peek, Result}; +use crate::token::{Float32, Float64}; + +/// Expression that can be used inside of `invoke` expressions for core wasm +/// functions. +#[derive(Debug)] +#[allow(missing_docs)] +pub enum WastVal<'a> { + Bool(bool), + U8(u8), + S8(i8), + U16(u16), + S16(i16), + U32(u32), + S32(i32), + U64(u64), + S64(i64), + Float32(Float32), + Float64(Float64), + Char(char), + String(&'a str), + List(Vec>), + Record(Vec<(&'a str, WastVal<'a>)>), + Tuple(Vec>), + Variant(&'a str, Option>>), + Enum(&'a str), + Union(u32, Box>), + Option(Option>>), + Result(Result>>, Option>>>), + Flags(Vec<&'a str>), +} + +static CASES: &[(&str, fn(Parser<'_>) -> Result>)] = { + use WastVal::*; + &[ + ("bool.const", |p| { + let mut l = p.lookahead1(); + if l.peek::() { + p.parse::()?; + Ok(Bool(true)) + } else if l.peek::() { + p.parse::()?; + Ok(Bool(false)) + } else { + Err(l.error()) + } + }), + ("u8.const", |p| Ok(U8(p.parse()?))), + ("s8.const", |p| Ok(S8(p.parse()?))), + ("u16.const", |p| Ok(U16(p.parse()?))), + ("s16.const", |p| Ok(S16(p.parse()?))), + ("u32.const", |p| Ok(U32(p.parse()?))), + ("s32.const", |p| Ok(S32(p.parse()?))), + ("u64.const", |p| Ok(U64(p.parse()?))), + ("s64.const", |p| Ok(S64(p.parse()?))), + ("f32.const", |p| Ok(Float32(p.parse()?))), + ("f64.const", |p| Ok(Float64(p.parse()?))), + ("char.const", |p| { + let s = p.parse::<&str>()?; + let mut ch = s.chars(); + let ret = match ch.next() { + Some(c) => c, + None => return Err(p.error("empty string")), + }; + if ch.next().is_some() { + return Err(p.error("more than one character")); + } + Ok(Char(ret)) + }), + ("str.const", |p| Ok(String(p.parse()?))), + ("list.const", |p| { + let mut ret = Vec::new(); + while !p.is_empty() { + ret.push(p.parens(|p| p.parse())?); + } + Ok(List(ret)) + }), + ("record.const", |p| { + let mut ret = Vec::new(); + while !p.is_empty() { + ret.push(p.parens(|p| { + p.parse::()?; + Ok((p.parse()?, p.parse()?)) + })?); + } + Ok(Record(ret)) + }), + ("tuple.const", |p| { + let mut ret = Vec::new(); + while !p.is_empty() { + ret.push(p.parens(|p| p.parse())?); + } + Ok(Tuple(ret)) + }), + ("variant.const", |p| { + let name = p.parse()?; + let payload = if p.is_empty() { + None + } else { + Some(Box::new(p.parse()?)) + }; + Ok(Variant(name, payload)) + }), + ("enum.const", |p| Ok(Enum(p.parse()?))), + ("union.const", |p| { + let num = p.parse()?; + let payload = Box::new(p.parse()?); + Ok(Union(num, payload)) + }), + ("option.none", |_| Ok(Option(None))), + ("option.some", |p| Ok(Option(Some(Box::new(p.parse()?))))), + ("result.ok", |p| { + Ok(Result(Ok(if p.is_empty() { + None + } else { + Some(Box::new(p.parse()?)) + }))) + }), + ("result.err", |p| { + Ok(Result(Err(if p.is_empty() { + None + } else { + Some(Box::new(p.parse()?)) + }))) + }), + ("flags.const", |p| { + let mut ret = Vec::new(); + while !p.is_empty() { + ret.push(p.parse()?); + } + Ok(Flags(ret)) + }), + ] +}; + +impl<'a> Parse<'a> for WastVal<'a> { + fn parse(parser: Parser<'a>) -> Result { + let parse = parser.step(|c| { + if let Some((kw, rest)) = c.keyword() { + if let Some(i) = CASES.iter().position(|(name, _)| *name == kw) { + return Ok((CASES[i].1, rest)); + } + } + Err(c.error("expected a [type].const expression")) + })?; + parse(parser) + } +} + +impl Peek for WastVal<'_> { + fn peek(cursor: Cursor<'_>) -> bool { + let kw = match cursor.keyword() { + Some((kw, _)) => kw, + None => return false, + }; + CASES.iter().any(|(name, _)| *name == kw) + } + + fn display() -> &'static str { + "core wasm argument" + } +} diff --git a/crates/wastlhw/src/core.rs b/crates/wastlhw/src/core.rs new file mode 100644 index 000000000..785a08185 --- /dev/null +++ b/crates/wastlhw/src/core.rs @@ -0,0 +1,29 @@ +//! Types and support for parsing the core wasm text format. + +mod custom; +mod export; +mod expr; +mod func; +mod global; +mod import; +mod memory; +mod module; +mod table; +mod tag; +mod types; +mod wast; +pub use self::custom::*; +pub use self::export::*; +pub use self::expr::*; +pub use self::func::*; +pub use self::global::*; +pub use self::import::*; +pub use self::memory::*; +pub use self::module::*; +pub use self::table::*; +pub use self::tag::*; +pub use self::types::*; +pub use self::wast::*; + +pub(crate) mod binary; +pub(crate) mod resolve; diff --git a/crates/wastlhw/src/core/binary.rs b/crates/wastlhw/src/core/binary.rs new file mode 100644 index 000000000..917dcb9e7 --- /dev/null +++ b/crates/wastlhw/src/core/binary.rs @@ -0,0 +1,1081 @@ +use crate::core::*; +use crate::encode::Encode; +use crate::token::*; + +pub fn encode( + module_id: &Option>, + module_name: &Option>, + fields: &[ModuleField<'_>], +) -> Vec { + use CustomPlace::*; + use CustomPlaceAnchor::*; + + let mut types = Vec::new(); + let mut imports = Vec::new(); + let mut funcs = Vec::new(); + let mut tables = Vec::new(); + let mut memories = Vec::new(); + let mut globals = Vec::new(); + let mut exports = Vec::new(); + let mut start = Vec::new(); + let mut elem = Vec::new(); + let mut data = Vec::new(); + let mut tags = Vec::new(); + let mut customs = Vec::new(); + for field in fields { + match field { + ModuleField::Type(i) => types.push(RecOrType::Type(i)), + ModuleField::Rec(i) => types.push(RecOrType::Rec(i)), + ModuleField::Import(i) => imports.push(i), + ModuleField::Func(i) => funcs.push(i), + ModuleField::Table(i) => tables.push(i), + ModuleField::Memory(i) => memories.push(i), + ModuleField::Global(i) => globals.push(i), + ModuleField::Export(i) => exports.push(i), + ModuleField::Start(i) => start.push(i), + ModuleField::Elem(i) => elem.push(i), + ModuleField::Data(i) => data.push(i), + ModuleField::Tag(i) => tags.push(i), + ModuleField::Custom(i) => customs.push(i), + } + } + + let mut e = Encoder { + wasm: Vec::new(), + tmp: Vec::new(), + customs: &customs, + }; + e.wasm.extend(b"\0asm"); + e.wasm.extend(b"\x01\0\0\0"); + + e.custom_sections(BeforeFirst); + + e.section_list(1, Type, &types); + e.section_list(2, Import, &imports); + + let functys = funcs.iter().map(|f| &f.ty).collect::>(); + e.section_list(3, Func, &functys); + e.section_list(4, Table, &tables); + e.section_list(5, Memory, &memories); + e.section_list(13, Tag, &tags); + e.section_list(6, Global, &globals); + e.section_list(7, Export, &exports); + e.custom_sections(Before(Start)); + if let Some(start) = start.get(0) { + e.section(8, start); + } + e.custom_sections(After(Start)); + e.section_list(9, Elem, &elem); + if needs_data_count(&funcs) { + e.section(12, &data.len()); + } + e.section_list(10, Code, &funcs); + e.section_list(11, Data, &data); + + let names = find_names(module_id, module_name, fields); + if !names.is_empty() { + e.section(0, &("name", names)); + } + e.custom_sections(AfterLast); + + return e.wasm; + + fn needs_data_count(funcs: &[&crate::core::Func<'_>]) -> bool { + funcs + .iter() + .filter_map(|f| match &f.kind { + FuncKind::Inline { expression, .. } => Some(expression), + _ => None, + }) + .flat_map(|e| e.instrs.iter()) + .any(|i| i.needs_data_count()) + } +} + +struct Encoder<'a> { + wasm: Vec, + tmp: Vec, + customs: &'a [&'a Custom<'a>], +} + +impl Encoder<'_> { + fn section(&mut self, id: u8, section: &dyn Encode) { + self.tmp.truncate(0); + section.encode(&mut self.tmp); + self.wasm.push(id); + self.tmp.encode(&mut self.wasm); + } + + fn custom_sections(&mut self, place: CustomPlace) { + for entry in self.customs.iter() { + if entry.place == place { + self.section(0, &(entry.name, entry)); + } + } + } + + fn section_list(&mut self, id: u8, anchor: CustomPlaceAnchor, list: &[impl Encode]) { + self.custom_sections(CustomPlace::Before(anchor)); + if !list.is_empty() { + self.section(id, &list) + } + self.custom_sections(CustomPlace::After(anchor)); + } +} + +impl Encode for FunctionType<'_> { + fn encode(&self, e: &mut Vec) { + self.params.len().encode(e); + for (_, _, ty) in self.params.iter() { + ty.encode(e); + } + self.results.encode(e); + } +} + +impl Encode for StructType<'_> { + fn encode(&self, e: &mut Vec) { + self.fields.len().encode(e); + for field in self.fields.iter() { + field.ty.encode(e); + (field.mutable as i32).encode(e); + } + } +} + +impl Encode for ArrayType<'_> { + fn encode(&self, e: &mut Vec) { + self.ty.encode(e); + (self.mutable as i32).encode(e); + } +} + +impl Encode for ExportType<'_> { + fn encode(&self, e: &mut Vec) { + self.name.encode(e); + self.item.encode(e); + } +} + +enum RecOrType<'a> { + Type(&'a Type<'a>), + Rec(&'a Rec<'a>), +} + +impl Encode for RecOrType<'_> { + fn encode(&self, e: &mut Vec) { + match self { + RecOrType::Type(ty) => ty.encode(e), + RecOrType::Rec(rec) => rec.encode(e), + } + } +} + +impl Encode for Type<'_> { + fn encode(&self, e: &mut Vec) { + if let Some(parent) = &self.parent { + e.push(0x50); + (1 as usize).encode(e); + parent.encode(e); + } + match &self.def { + TypeDef::Func(func) => { + e.push(0x60); + func.encode(e) + } + TypeDef::Struct(r#struct) => { + e.push(0x5f); + r#struct.encode(e) + } + TypeDef::Array(array) => { + e.push(0x5e); + array.encode(e) + } + } + } +} + +impl Encode for Rec<'_> { + fn encode(&self, e: &mut Vec) { + if self.types.len() == 1 { + self.types[0].encode(e); + return; + } + + e.push(0x45); + self.types.len().encode(e); + for ty in &self.types { + ty.encode(e); + } + } +} + +impl Encode for Option> { + fn encode(&self, _e: &mut Vec) { + // used for parameters in the tuple impl as well as instruction labels + } +} + +impl<'a> Encode for ValType<'a> { + fn encode(&self, e: &mut Vec) { + match self { + ValType::I32 => e.push(0x7f), + ValType::I64 => e.push(0x7e), + ValType::F32 => e.push(0x7d), + ValType::F64 => e.push(0x7c), + ValType::V128 => e.push(0x7b), + ValType::Ref(ty) => { + ty.encode(e); + } + } + } +} + +impl<'a> Encode for HeapType<'a> { + fn encode(&self, e: &mut Vec) { + match self { + HeapType::Func => e.push(0x70), + HeapType::Extern => e.push(0x6f), + HeapType::Any => e.push(0x6e), + HeapType::Eq => e.push(0x6d), + HeapType::Data => e.push(0x67), + HeapType::Array => e.push(0x66), + HeapType::I31 => e.push(0x6a), + HeapType::Index(index) => { + index.encode(e); + } + } + } +} + +impl<'a> Encode for RefType<'a> { + fn encode(&self, e: &mut Vec) { + match self { + // The 'funcref' binary abbreviation + RefType { + nullable: true, + heap: HeapType::Func, + } => e.push(0x70), + // The 'externref' binary abbreviation + RefType { + nullable: true, + heap: HeapType::Extern, + } => e.push(0x6f), + // The 'eqref' binary abbreviation + RefType { + nullable: true, + heap: HeapType::Eq, + } => e.push(0x6d), + // The 'dataref' binary abbreviation + RefType { + nullable: true, + heap: HeapType::Data, + } => e.push(0x67), + // The 'i31ref' binary abbreviation + RefType { + nullable: true, + heap: HeapType::I31, + } => e.push(0x6a), + + // Generic 'ref opt ' encoding + RefType { + nullable: true, + heap, + } => { + e.push(0x6c); + heap.encode(e); + } + // Generic 'ref ' encoding + RefType { + nullable: false, + heap, + } => { + e.push(0x6b); + heap.encode(e); + } + } + } +} + +impl<'a> Encode for StorageType<'a> { + fn encode(&self, e: &mut Vec) { + match self { + StorageType::I8 => e.push(0x7a), + StorageType::I16 => e.push(0x79), + StorageType::Val(ty) => { + ty.encode(e); + } + } + } +} + +impl Encode for Import<'_> { + fn encode(&self, e: &mut Vec) { + self.module.encode(e); + self.field.encode(e); + self.item.encode(e); + } +} + +impl Encode for ItemSig<'_> { + fn encode(&self, e: &mut Vec) { + match &self.kind { + ItemKind::Func(f) => { + e.push(0x00); + f.encode(e); + } + ItemKind::Table(f) => { + e.push(0x01); + f.encode(e); + } + ItemKind::Memory(f) => { + e.push(0x02); + f.encode(e); + } + ItemKind::Global(f) => { + e.push(0x03); + f.encode(e); + } + ItemKind::Tag(f) => { + e.push(0x04); + f.encode(e); + } + } + } +} + +impl Encode for TypeUse<'_, T> { + fn encode(&self, e: &mut Vec) { + self.index + .as_ref() + .expect("TypeUse should be filled in by this point") + .encode(e) + } +} + +impl Encode for Index<'_> { + fn encode(&self, e: &mut Vec) { + match self { + Index::Num(n, _) => n.encode(e), + Index::Id(n) => panic!("unresolved index in emission: {:?}", n), + } + } +} + +impl<'a> Encode for TableType<'a> { + fn encode(&self, e: &mut Vec) { + self.elem.encode(e); + self.limits.encode(e); + } +} + +impl Encode for Limits { + fn encode(&self, e: &mut Vec) { + match self.max { + Some(max) => { + e.push(0x01); + self.min.encode(e); + max.encode(e); + } + None => { + e.push(0x00); + self.min.encode(e); + } + } + } +} + +impl Encode for MemoryType { + fn encode(&self, e: &mut Vec) { + match self { + MemoryType::B32 { limits, shared } => { + let flag_max = limits.max.is_some() as u8; + let flag_shared = *shared as u8; + let flags = flag_max | (flag_shared << 1); + e.push(flags); + limits.min.encode(e); + if let Some(max) = limits.max { + max.encode(e); + } + } + MemoryType::B64 { limits, shared } => { + let flag_max = limits.max.is_some() as u8; + let flag_shared = *shared as u8; + let flags = flag_max | (flag_shared << 1) | 0x04; + e.push(flags); + limits.min.encode(e); + if let Some(max) = limits.max { + max.encode(e); + } + } + } + } +} + +impl<'a> Encode for GlobalType<'a> { + fn encode(&self, e: &mut Vec) { + self.ty.encode(e); + if self.mutable { + e.push(0x01); + } else { + e.push(0x00); + } + } +} + +impl Encode for Table<'_> { + fn encode(&self, e: &mut Vec) { + assert!(self.exports.names.is_empty()); + match &self.kind { + TableKind::Normal(t) => t.encode(e), + _ => panic!("TableKind should be normal during encoding"), + } + } +} + +impl Encode for Memory<'_> { + fn encode(&self, e: &mut Vec) { + assert!(self.exports.names.is_empty()); + match &self.kind { + MemoryKind::Normal(t) => t.encode(e), + _ => panic!("MemoryKind should be normal during encoding"), + } + } +} + +impl Encode for Global<'_> { + fn encode(&self, e: &mut Vec) { + assert!(self.exports.names.is_empty()); + self.ty.encode(e); + match &self.kind { + GlobalKind::Inline(expr) => expr.encode(e), + _ => panic!("GlobalKind should be inline during encoding"), + } + } +} + +impl Encode for Export<'_> { + fn encode(&self, e: &mut Vec) { + self.name.encode(e); + self.kind.encode(e); + self.item.encode(e); + } +} + +impl Encode for ExportKind { + fn encode(&self, e: &mut Vec) { + match self { + ExportKind::Func => e.push(0x00), + ExportKind::Table => e.push(0x01), + ExportKind::Memory => e.push(0x02), + ExportKind::Global => e.push(0x03), + ExportKind::Tag => e.push(0x04), + } + } +} + +impl Encode for Elem<'_> { + fn encode(&self, e: &mut Vec) { + match (&self.kind, &self.payload) { + ( + ElemKind::Active { + table: Index::Num(0, _), + offset, + }, + ElemPayload::Indices(_), + ) => { + e.push(0x00); + offset.encode(e); + } + (ElemKind::Passive, ElemPayload::Indices(_)) => { + e.push(0x01); // flags + e.push(0x00); // extern_kind + } + (ElemKind::Active { table, offset }, ElemPayload::Indices(_)) => { + e.push(0x02); // flags + table.encode(e); + offset.encode(e); + e.push(0x00); // extern_kind + } + ( + ElemKind::Active { + table: Index::Num(0, _), + offset, + }, + ElemPayload::Exprs { + ty: + RefType { + nullable: true, + heap: HeapType::Func, + }, + .. + }, + ) => { + e.push(0x04); + offset.encode(e); + } + (ElemKind::Passive, ElemPayload::Exprs { ty, .. }) => { + e.push(0x05); + ty.encode(e); + } + (ElemKind::Active { table, offset }, ElemPayload::Exprs { ty, .. }) => { + e.push(0x06); + table.encode(e); + offset.encode(e); + ty.encode(e); + } + (ElemKind::Declared, ElemPayload::Indices(_)) => { + e.push(0x03); // flags + e.push(0x00); // extern_kind + } + (ElemKind::Declared, ElemPayload::Exprs { ty, .. }) => { + e.push(0x07); // flags + ty.encode(e); + } + } + + self.payload.encode(e); + } +} + +impl Encode for ElemPayload<'_> { + fn encode(&self, e: &mut Vec) { + match self { + ElemPayload::Indices(v) => v.encode(e), + ElemPayload::Exprs { exprs, ty: _ } => { + exprs.len().encode(e); + for expr in exprs { + expr.encode(e); + } + } + } + } +} + +impl Encode for Data<'_> { + fn encode(&self, e: &mut Vec) { + match &self.kind { + DataKind::Passive => e.push(0x01), + DataKind::Active { + memory: Index::Num(0, _), + offset, + } => { + e.push(0x00); + offset.encode(e); + } + DataKind::Active { memory, offset } => { + e.push(0x02); + memory.encode(e); + offset.encode(e); + } + } + self.data.iter().map(|l| l.len()).sum::().encode(e); + for val in self.data.iter() { + val.push_onto(e); + } + } +} + +impl Encode for Func<'_> { + fn encode(&self, e: &mut Vec) { + assert!(self.exports.names.is_empty()); + let mut tmp = Vec::new(); + let (expr, locals) = match &self.kind { + FuncKind::Inline { expression, locals } => (expression, locals), + _ => panic!("should only have inline functions in emission"), + }; + + locals.encode(&mut tmp); + expr.encode(&mut tmp); + + tmp.len().encode(e); + e.extend_from_slice(&tmp); + } +} + +impl Encode for Vec> { + fn encode(&self, e: &mut Vec) { + let mut locals_compressed = Vec::<(u32, ValType)>::new(); + for local in self { + if let Some((cnt, prev)) = locals_compressed.last_mut() { + if *prev == local.ty { + *cnt += 1; + continue; + } + } + locals_compressed.push((1, local.ty)); + } + locals_compressed.encode(e); + } +} + +impl Encode for Expression<'_> { + fn encode(&self, e: &mut Vec) { + for instr in self.instrs.iter() { + instr.encode(e); + } + e.push(0x0b); + } +} + +impl Encode for BlockType<'_> { + fn encode(&self, e: &mut Vec) { + // block types using an index are encoded as an sleb, not a uleb + if let Some(Index::Num(n, _)) = &self.ty.index { + return i64::from(*n).encode(e); + } + let ty = self + .ty + .inline + .as_ref() + .expect("function type not filled in"); + if ty.params.is_empty() && ty.results.is_empty() { + return e.push(0x40); + } + if ty.params.is_empty() && ty.results.len() == 1 { + return ty.results[0].encode(e); + } + panic!("multi-value block types should have an index"); + } +} + +impl Encode for FuncBindType<'_> { + fn encode(&self, e: &mut Vec) { + self.ty.encode(e); + } +} + +impl Encode for LetType<'_> { + fn encode(&self, e: &mut Vec) { + self.block.encode(e); + self.locals.encode(e); + } +} + +impl Encode for LaneArg { + fn encode(&self, e: &mut Vec) { + self.lane.encode(e); + } +} + +impl Encode for MemArg<'_> { + fn encode(&self, e: &mut Vec) { + match &self.memory { + Index::Num(0, _) => { + self.align.trailing_zeros().encode(e); + self.offset.encode(e); + } + _ => { + (self.align.trailing_zeros() | (1 << 6)).encode(e); + self.memory.encode(e); + self.offset.encode(e); + } + } + } +} + +impl Encode for LoadOrStoreLane<'_> { + fn encode(&self, e: &mut Vec) { + self.memarg.encode(e); + self.lane.encode(e); + } +} + +impl Encode for CallIndirect<'_> { + fn encode(&self, e: &mut Vec) { + self.ty.encode(e); + self.table.encode(e); + } +} + +impl Encode for TableInit<'_> { + fn encode(&self, e: &mut Vec) { + self.elem.encode(e); + self.table.encode(e); + } +} + +impl Encode for TableCopy<'_> { + fn encode(&self, e: &mut Vec) { + self.dst.encode(e); + self.src.encode(e); + } +} + +impl Encode for TableArg<'_> { + fn encode(&self, e: &mut Vec) { + self.dst.encode(e); + } +} + +impl Encode for MemoryArg<'_> { + fn encode(&self, e: &mut Vec) { + self.mem.encode(e); + } +} + +impl Encode for MemoryInit<'_> { + fn encode(&self, e: &mut Vec) { + self.data.encode(e); + self.mem.encode(e); + } +} + +impl Encode for MemoryCopy<'_> { + fn encode(&self, e: &mut Vec) { + self.dst.encode(e); + self.src.encode(e); + } +} + +impl Encode for BrTableIndices<'_> { + fn encode(&self, e: &mut Vec) { + self.labels.encode(e); + self.default.encode(e); + } +} + +impl Encode for Float32 { + fn encode(&self, e: &mut Vec) { + e.extend_from_slice(&self.bits.to_le_bytes()); + } +} + +impl Encode for Float64 { + fn encode(&self, e: &mut Vec) { + e.extend_from_slice(&self.bits.to_le_bytes()); + } +} + +#[derive(Default)] +struct Names<'a> { + module: Option<&'a str>, + funcs: Vec<(u32, &'a str)>, + func_idx: u32, + locals: Vec<(u32, Vec<(u32, &'a str)>)>, + labels: Vec<(u32, Vec<(u32, &'a str)>)>, + globals: Vec<(u32, &'a str)>, + global_idx: u32, + memories: Vec<(u32, &'a str)>, + memory_idx: u32, + tables: Vec<(u32, &'a str)>, + table_idx: u32, + tags: Vec<(u32, &'a str)>, + tag_idx: u32, + types: Vec<(u32, &'a str)>, + type_idx: u32, + data: Vec<(u32, &'a str)>, + data_idx: u32, + elems: Vec<(u32, &'a str)>, + elem_idx: u32, +} + +fn find_names<'a>( + module_id: &Option>, + module_name: &Option>, + fields: &[ModuleField<'a>], +) -> Names<'a> { + fn get_name<'a>(id: &Option>, name: &Option>) -> Option<&'a str> { + name.as_ref().map(|n| n.name).or(id.and_then(|id| { + if id.is_gensym() { + None + } else { + Some(id.name()) + } + })) + } + + enum Name { + Type, + Global, + Func, + Memory, + Table, + Tag, + Elem, + Data, + } + + let mut ret = Names::default(); + ret.module = get_name(module_id, module_name); + let mut names = Vec::new(); + for field in fields { + // Extract the kind/id/name from whatever kind of field this is... + let (kind, id, name) = match field { + ModuleField::Import(i) => ( + match i.item.kind { + ItemKind::Func(_) => Name::Func, + ItemKind::Table(_) => Name::Table, + ItemKind::Memory(_) => Name::Memory, + ItemKind::Global(_) => Name::Global, + ItemKind::Tag(_) => Name::Tag, + }, + &i.item.id, + &i.item.name, + ), + ModuleField::Global(g) => (Name::Global, &g.id, &g.name), + ModuleField::Table(t) => (Name::Table, &t.id, &t.name), + ModuleField::Memory(m) => (Name::Memory, &m.id, &m.name), + ModuleField::Tag(t) => (Name::Tag, &t.id, &t.name), + ModuleField::Type(t) => (Name::Type, &t.id, &t.name), + ModuleField::Rec(r) => { + for ty in &r.types { + names.push((Name::Type, &ty.id, &ty.name, field)); + } + continue; + } + ModuleField::Elem(e) => (Name::Elem, &e.id, &e.name), + ModuleField::Data(d) => (Name::Data, &d.id, &d.name), + ModuleField::Func(f) => (Name::Func, &f.id, &f.name), + ModuleField::Export(_) | ModuleField::Start(_) | ModuleField::Custom(_) => continue, + }; + names.push((kind, id, name, field)); + } + + for (kind, id, name, field) in names { + // .. and using the kind we can figure out where to place this name + let (list, idx) = match kind { + Name::Func => (&mut ret.funcs, &mut ret.func_idx), + Name::Table => (&mut ret.tables, &mut ret.table_idx), + Name::Memory => (&mut ret.memories, &mut ret.memory_idx), + Name::Global => (&mut ret.globals, &mut ret.global_idx), + Name::Tag => (&mut ret.tags, &mut ret.tag_idx), + Name::Type => (&mut ret.types, &mut ret.type_idx), + Name::Elem => (&mut ret.elems, &mut ret.elem_idx), + Name::Data => (&mut ret.data, &mut ret.data_idx), + }; + if let Some(name) = get_name(id, name) { + list.push((*idx, name)); + } + + // Handle module locals separately from above + if let ModuleField::Func(f) = field { + let mut local_names = Vec::new(); + let mut label_names = Vec::new(); + let mut local_idx = 0; + let mut label_idx = 0; + + // Consult the inline type listed for local names of parameters. + // This is specifically preserved during the name resolution + // pass, but only for functions, so here we can look at the + // original source's names. + if let Some(ty) = &f.ty.inline { + for (id, name, _) in ty.params.iter() { + if let Some(name) = get_name(id, name) { + local_names.push((local_idx, name)); + } + local_idx += 1; + } + } + if let FuncKind::Inline { + locals, expression, .. + } = &f.kind + { + for local in locals { + if let Some(name) = get_name(&local.id, &local.name) { + local_names.push((local_idx, name)); + } + local_idx += 1; + } + + for i in expression.instrs.iter() { + match i { + Instruction::If(block) + | Instruction::Block(block) + | Instruction::Loop(block) + | Instruction::Try(block) + | Instruction::Let(LetType { block, .. }) => { + if let Some(name) = get_name(&block.label, &block.label_name) { + label_names.push((label_idx, name)); + } + label_idx += 1; + } + _ => {} + } + } + } + if local_names.len() > 0 { + ret.locals.push((*idx, local_names)); + } + if label_names.len() > 0 { + ret.labels.push((*idx, label_names)); + } + } + + *idx += 1; + } + + return ret; +} + +impl Names<'_> { + fn is_empty(&self) -> bool { + self.module.is_none() + && self.funcs.is_empty() + && self.locals.is_empty() + && self.labels.is_empty() + && self.globals.is_empty() + && self.memories.is_empty() + && self.tables.is_empty() + && self.types.is_empty() + && self.data.is_empty() + && self.elems.is_empty() + // NB: specifically don't check tags/modules/instances since they're + // not encoded for now. + } +} + +impl Encode for Names<'_> { + fn encode(&self, dst: &mut Vec) { + let mut tmp = Vec::new(); + + let mut subsec = |id: u8, data: &mut Vec| { + dst.push(id); + data.encode(dst); + data.truncate(0); + }; + + if let Some(id) = self.module { + id.encode(&mut tmp); + subsec(0, &mut tmp); + } + if self.funcs.len() > 0 { + self.funcs.encode(&mut tmp); + subsec(1, &mut tmp); + } + if self.locals.len() > 0 { + self.locals.encode(&mut tmp); + subsec(2, &mut tmp); + } + if self.labels.len() > 0 { + self.labels.encode(&mut tmp); + subsec(3, &mut tmp); + } + if self.types.len() > 0 { + self.types.encode(&mut tmp); + subsec(4, &mut tmp); + } + if self.tables.len() > 0 { + self.tables.encode(&mut tmp); + subsec(5, &mut tmp); + } + if self.memories.len() > 0 { + self.memories.encode(&mut tmp); + subsec(6, &mut tmp); + } + if self.globals.len() > 0 { + self.globals.encode(&mut tmp); + subsec(7, &mut tmp); + } + if self.elems.len() > 0 { + self.elems.encode(&mut tmp); + subsec(8, &mut tmp); + } + if self.data.len() > 0 { + self.data.encode(&mut tmp); + subsec(9, &mut tmp); + } + } +} + +impl Encode for Id<'_> { + fn encode(&self, dst: &mut Vec) { + assert!(!self.is_gensym()); + self.name().encode(dst); + } +} + +impl Encode for V128Const { + fn encode(&self, dst: &mut Vec) { + dst.extend_from_slice(&self.to_le_bytes()); + } +} + +impl Encode for I8x16Shuffle { + fn encode(&self, dst: &mut Vec) { + dst.extend_from_slice(&self.lanes); + } +} + +impl<'a> Encode for SelectTypes<'a> { + fn encode(&self, dst: &mut Vec) { + match &self.tys { + Some(list) => { + dst.push(0x1c); + list.encode(dst); + } + None => dst.push(0x1b), + } + } +} + +impl Encode for Custom<'_> { + fn encode(&self, e: &mut Vec) { + for list in self.data.iter() { + e.extend_from_slice(list); + } + } +} + +impl Encode for Tag<'_> { + fn encode(&self, e: &mut Vec) { + self.ty.encode(e); + match &self.kind { + TagKind::Inline() => {} + _ => panic!("TagKind should be inline during encoding"), + } + } +} + +impl Encode for TagType<'_> { + fn encode(&self, e: &mut Vec) { + match self { + TagType::Exception(ty) => { + e.push(0x00); + ty.encode(e); + } + } + } +} + +impl Encode for StructAccess<'_> { + fn encode(&self, e: &mut Vec) { + self.r#struct.encode(e); + self.field.encode(e); + } +} + +impl Encode for ArrayCopy<'_> { + fn encode(&self, e: &mut Vec) { + self.dest_array.encode(e); + self.src_array.encode(e); + } +} + +impl Encode for ArrayNewFixed<'_> { + fn encode(&self, e: &mut Vec) { + self.array.encode(e); + self.length.encode(e); + } +} + +impl Encode for ArrayNewData<'_> { + fn encode(&self, e: &mut Vec) { + self.array.encode(e); + self.data_idx.encode(e); + } +} + +impl Encode for ArrayNewElem<'_> { + fn encode(&self, e: &mut Vec) { + self.array.encode(e); + self.elem_idx.encode(e); + } +} + +impl Encode for BrOnCast<'_> { + fn encode(&self, e: &mut Vec) { + self.label.encode(e); + self.r#type.encode(e); + } +} diff --git a/crates/wastlhw/src/core/custom.rs b/crates/wastlhw/src/core/custom.rs new file mode 100644 index 000000000..ea2a60467 --- /dev/null +++ b/crates/wastlhw/src/core/custom.rs @@ -0,0 +1,151 @@ +use crate::parser::{Parse, Parser, Result}; +use crate::token::{self, Span}; +use crate::{annotation, kw}; + +/// A wasm custom section within a module. +#[derive(Debug)] +pub struct Custom<'a> { + /// Where this `@custom` was defined. + pub span: Span, + + /// Name of the custom section. + pub name: &'a str, + + /// Where the custom section is being placed, + pub place: CustomPlace, + + /// Payload of this custom section. + pub data: Vec<&'a [u8]>, +} + +/// Possible locations to place a custom section within a module. +#[derive(Debug, PartialEq, Copy, Clone)] +pub enum CustomPlace { + /// This custom section will appear before the first section in the module. + BeforeFirst, + /// This custom section will be placed just before a known section. + Before(CustomPlaceAnchor), + /// This custom section will be placed just after a known section. + After(CustomPlaceAnchor), + /// This custom section will appear after the last section in the module. + AfterLast, +} + +/// Known sections that custom sections can be placed relative to. +#[derive(Debug, PartialEq, Copy, Clone)] +#[allow(missing_docs)] +pub enum CustomPlaceAnchor { + Type, + Import, + Func, + Table, + Memory, + Global, + Export, + Start, + Elem, + Code, + Data, + Tag, +} + +impl<'a> Parse<'a> for Custom<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let name = parser.parse()?; + let place = if parser.peek::() { + parser.parens(|p| p.parse())? + } else { + CustomPlace::AfterLast + }; + let mut data = Vec::new(); + while !parser.is_empty() { + data.push(parser.parse()?); + } + Ok(Custom { + span, + name, + place, + data, + }) + } +} + +impl<'a> Parse<'a> for CustomPlace { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + let ctor = if l.peek::() { + parser.parse::()?; + if l.peek::() { + parser.parse::()?; + return Ok(CustomPlace::BeforeFirst); + } + CustomPlace::Before as fn(CustomPlaceAnchor) -> _ + } else if l.peek::() { + parser.parse::()?; + if l.peek::() { + parser.parse::()?; + return Ok(CustomPlace::AfterLast); + } + CustomPlace::After + } else { + return Err(l.error()); + }; + Ok(ctor(parser.parse()?)) + } +} + +impl<'a> Parse<'a> for CustomPlaceAnchor { + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::() { + parser.parse::()?; + return Ok(CustomPlaceAnchor::Type); + } + if parser.peek::() { + parser.parse::()?; + return Ok(CustomPlaceAnchor::Import); + } + if parser.peek::() { + parser.parse::()?; + return Ok(CustomPlaceAnchor::Func); + } + if parser.peek::() { + parser.parse::()?; + return Ok(CustomPlaceAnchor::Table); + } + if parser.peek::() { + parser.parse::()?; + return Ok(CustomPlaceAnchor::Memory); + } + if parser.peek::() { + parser.parse::()?; + return Ok(CustomPlaceAnchor::Global); + } + if parser.peek::() { + parser.parse::()?; + return Ok(CustomPlaceAnchor::Export); + } + if parser.peek::() { + parser.parse::()?; + return Ok(CustomPlaceAnchor::Start); + } + if parser.peek::() { + parser.parse::()?; + return Ok(CustomPlaceAnchor::Elem); + } + if parser.peek::() { + parser.parse::()?; + return Ok(CustomPlaceAnchor::Code); + } + if parser.peek::() { + parser.parse::()?; + return Ok(CustomPlaceAnchor::Data); + } + if parser.peek::() { + parser.parse::()?; + return Ok(CustomPlaceAnchor::Tag); + } + + Err(parser.error("expected a valid section name")) + } +} diff --git a/crates/wastlhw/src/core/export.rs b/crates/wastlhw/src/core/export.rs new file mode 100644 index 000000000..66354d054 --- /dev/null +++ b/crates/wastlhw/src/core/export.rs @@ -0,0 +1,146 @@ +use crate::kw; +use crate::parser::{Cursor, Parse, Parser, Peek, Result}; +use crate::token::{Index, Span}; + +/// A entry in a WebAssembly module's export section. +#[derive(Debug)] +pub struct Export<'a> { + /// Where this export was defined. + pub span: Span, + /// The name of this export from the module. + pub name: &'a str, + /// The kind of item being exported. + pub kind: ExportKind, + /// What's being exported from the module. + pub item: Index<'a>, +} + +/// Different kinds of elements that can be exported from a WebAssembly module, +/// contained in an [`Export`]. +#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)] +#[allow(missing_docs)] +pub enum ExportKind { + Func, + Table, + Memory, + Global, + Tag, +} + +impl<'a> Parse<'a> for Export<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let name = parser.parse()?; + let (kind, item) = parser.parens(|p| Ok((p.parse()?, p.parse()?)))?; + Ok(Export { + span, + name, + kind, + item, + }) + } +} + +impl<'a> Parse<'a> for ExportKind { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + Ok(ExportKind::Func) + } else if l.peek::() { + parser.parse::()?; + Ok(ExportKind::Table) + } else if l.peek::() { + parser.parse::()?; + Ok(ExportKind::Memory) + } else if l.peek::() { + parser.parse::()?; + Ok(ExportKind::Global) + } else if l.peek::() { + parser.parse::()?; + Ok(ExportKind::Tag) + } else { + Err(l.error()) + } + } +} + +impl Peek for ExportKind { + fn peek(cursor: Cursor<'_>) -> bool { + kw::func::peek(cursor) + || kw::table::peek(cursor) + || kw::memory::peek(cursor) + || kw::global::peek(cursor) + || kw::tag::peek(cursor) + } + fn display() -> &'static str { + "export kind" + } +} + +macro_rules! kw_conversions { + ($($kw:ident => $kind:ident)*) => ($( + impl From for ExportKind { + fn from(_: kw::$kw) -> ExportKind { + ExportKind::$kind + } + } + + impl Default for kw::$kw { + fn default() -> kw::$kw { + kw::$kw(Span::from_offset(0)) + } + } + )*); +} + +kw_conversions! { + func => Func + table => Table + global => Global + tag => Tag + memory => Memory +} + +/// A listing of inline `(export "foo")` statements on a WebAssembly item in +/// its textual format. +#[derive(Debug, Default)] +pub struct InlineExport<'a> { + /// The extra names to export an item as, if any. + pub names: Vec<&'a str>, +} + +impl<'a> Parse<'a> for InlineExport<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut names = Vec::new(); + while parser.peek::() { + names.push(parser.parens(|p| { + p.parse::()?; + p.parse::<&str>() + })?); + } + Ok(InlineExport { names }) + } +} + +impl Peek for InlineExport<'_> { + fn peek(cursor: Cursor<'_>) -> bool { + let cursor = match cursor.lparen() { + Some(cursor) => cursor, + None => return false, + }; + let cursor = match cursor.keyword() { + Some(("export", cursor)) => cursor, + _ => return false, + }; + let cursor = match cursor.string() { + Some((_, cursor)) => cursor, + None => return false, + }; + cursor.rparen().is_some() + } + + fn display() -> &'static str { + "inline export" + } +} diff --git a/crates/wastlhw/src/core/expr.rs b/crates/wastlhw/src/core/expr.rs new file mode 100644 index 000000000..1e85f60cc --- /dev/null +++ b/crates/wastlhw/src/core/expr.rs @@ -0,0 +1,1886 @@ +use crate::core::*; +use crate::encode::Encode; +use crate::kw; +use crate::parser::{Cursor, Parse, Parser, Result}; +use crate::token::*; +use std::mem; + +/// An expression, or a list of instructions, in the WebAssembly text format. +/// +/// This expression type will parse s-expression-folded instructions into a flat +/// list of instructions for emission later on. The implicit `end` instruction +/// at the end of an expression is not included in the `instrs` field. +#[derive(Debug)] +#[allow(missing_docs)] +pub struct Expression<'a> { + pub instrs: Box<[Instruction<'a>]>, +} + +impl<'a> Parse<'a> for Expression<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut exprs = ExpressionParser::default(); + exprs.parse(parser)?; + Ok(Expression { + instrs: exprs.instrs.into(), + }) + } +} + +/// Helper struct used to parse an `Expression` with helper methods and such. +/// +/// The primary purpose of this is to avoid defining expression parsing as a +/// call-thread-stack recursive function. Since we're parsing user input that +/// runs the risk of blowing the call stack, so we want to be sure to use a heap +/// stack structure wherever possible. +#[derive(Default)] +struct ExpressionParser<'a> { + /// The flat list of instructions that we've parsed so far, and will + /// eventually become the final `Expression`. + instrs: Vec>, + + /// Descriptor of all our nested s-expr blocks. This only happens when + /// instructions themselves are nested. + stack: Vec>, +} + +enum Paren { + None, + Left, + Right, +} + +/// A "kind" of nested block that we can be parsing inside of. +enum Level<'a> { + /// This is a normal `block` or `loop` or similar, where the instruction + /// payload here is pushed when the block is exited. + EndWith(Instruction<'a>), + + /// This is a pretty special variant which means that we're parsing an `if` + /// statement, and the state of the `if` parsing is tracked internally in + /// the payload. + If(If<'a>), + + /// This means we're either parsing inside of `(then ...)` or `(else ...)` + /// which don't correspond to terminating instructions, we're just in a + /// nested block. + IfArm, + + /// Similar to `If` but for `Try` statements, which has simpler parsing + /// state to track. + Try(Try<'a>), + + /// Similar to `IfArm` but for `(do ...)` and `(catch ...)` blocks. + TryArm, +} + +/// Possible states of "what should be parsed next?" in an `if` expression. +enum If<'a> { + /// Only the `if` has been parsed, next thing to parse is the clause, if + /// any, of the `if` instruction. + Clause(Instruction<'a>), + /// Next thing to parse is the `then` block + Then(Instruction<'a>), + /// Next thing to parse is the `else` block + Else, + /// This `if` statement has finished parsing and if anything remains it's a + /// syntax error. + End, +} + +/// Possible state of "what should be parsed next?" in a `try` expression. +enum Try<'a> { + /// Next thing to parse is the `do` block. + Do(Instruction<'a>), + /// Next thing to parse is `catch`/`catch_all`, or `delegate`. + CatchOrDelegate, + /// Next thing to parse is a `catch` block or `catch_all`. + Catch, + /// Finished parsing like the `End` case, but does not push `end` opcode. + Delegate, + /// This `try` statement has finished parsing and if anything remains it's a + /// syntax error. + End, +} + +impl<'a> ExpressionParser<'a> { + fn parse(&mut self, parser: Parser<'a>) -> Result<()> { + // Here we parse instructions in a loop, and we do not recursively + // invoke this parse function to avoid blowing the stack on + // deeply-recursive parses. + // + // Our loop generally only finishes once there's no more input left int + // the `parser`. If there's some unclosed delimiters though (on our + // `stack`), then we also keep parsing to generate error messages if + // there's no input left. + while !parser.is_empty() || !self.stack.is_empty() { + // As a small ease-of-life adjustment here, if we're parsing inside + // of an `if block then we require that all sub-components are + // s-expressions surrounded by `(` and `)`, so verify that here. + if let Some(Level::If(_)) | Some(Level::Try(_)) = self.stack.last() { + if !parser.is_empty() && !parser.peek::() { + return Err(parser.error("expected `(`")); + } + } + + match self.paren(parser)? { + // No parenthesis seen? Then we just parse the next instruction + // and move on. + Paren::None => self.instrs.push(parser.parse()?), + + // If we see a left-parenthesis then things are a little + // special. We handle block-like instructions specially + // (`block`, `loop`, and `if`), and otherwise all other + // instructions simply get appended once we reach the end of the + // s-expression. + // + // In all cases here we push something onto the `stack` to get + // popped when the `)` character is seen. + Paren::Left => { + // First up is handling `if` parsing, which is funky in a + // whole bunch of ways. See the method internally for more + // information. + if self.handle_if_lparen(parser)? { + continue; + } + // Second, we handle `try` parsing, which is simpler than + // `if` but more complicated than, e.g., `block`. + if self.handle_try_lparen(parser)? { + continue; + } + match parser.parse()? { + // If block/loop show up then we just need to be sure to + // push an `end` instruction whenever the `)` token is + // seen + i @ Instruction::Block(_) + | i @ Instruction::Loop(_) + | i @ Instruction::Let(_) => { + self.instrs.push(i); + self.stack.push(Level::EndWith(Instruction::End(None))); + } + + // Parsing an `if` instruction is super tricky, so we + // push an `If` scope and we let all our scope-based + // parsing handle the remaining items. + i @ Instruction::If(_) => { + self.stack.push(Level::If(If::Clause(i))); + } + + // Parsing a `try` is easier than `if` but we also push + // a `Try` scope to handle the required nested blocks. + i @ Instruction::Try(_) => { + self.stack.push(Level::Try(Try::Do(i))); + } + + // Anything else means that we're parsing a nested form + // such as `(i32.add ...)` which means that the + // instruction we parsed will be coming at the end. + other => self.stack.push(Level::EndWith(other)), + } + } + + // If we registered a `)` token as being seen, then we're + // guaranteed there's an item in the `stack` stack for us to + // pop. We peel that off and take a look at what it says to do. + Paren::Right => match self.stack.pop().unwrap() { + Level::EndWith(i) => self.instrs.push(i), + Level::IfArm => {} + Level::TryArm => {} + + // If an `if` statement hasn't parsed the clause or `then` + // block, then that's an error because there weren't enough + // items in the `if` statement. Otherwise we're just careful + // to terminate with an `end` instruction. + Level::If(If::Clause(_)) => { + return Err(parser.error("previous `if` had no clause")); + } + Level::If(If::Then(_)) => { + return Err(parser.error("previous `if` had no `then`")); + } + Level::If(_) => { + self.instrs.push(Instruction::End(None)); + } + + // The `do` clause is required in a `try` statement, so + // we will signal that error here. Otherwise, terminate with + // an `end` or `delegate` instruction. + Level::Try(Try::Do(_)) => { + return Err(parser.error("previous `try` had no `do`")); + } + Level::Try(Try::Delegate) => {} + Level::Try(_) => { + self.instrs.push(Instruction::End(None)); + } + }, + } + } + + Ok(()) + } + + /// Parses either `(`, `)`, or nothing. + fn paren(&self, parser: Parser<'a>) -> Result { + parser.step(|cursor| { + Ok(match cursor.lparen() { + Some(rest) => (Paren::Left, rest), + None if self.stack.is_empty() => (Paren::None, cursor), + None => match cursor.rparen() { + Some(rest) => (Paren::Right, rest), + None => (Paren::None, cursor), + }, + }) + }) + } + + /// Handles all parsing of an `if` statement. + /// + /// The syntactical form of an `if` stament looks like: + /// + /// ```wat + /// (if $clause (then $then) (else $else)) + /// ``` + /// + /// but it turns out we practically see a few things in the wild: + /// + /// * inside the `(if ...)` every sub-thing is surrounded by parens + /// * The `then` and `else` keywords are optional + /// * The `$then` and `$else` blocks don't need to be surrounded by parens + /// + /// That's all attempted to be handled here. The part about all sub-parts + /// being surrounded by `(` and `)` means that we hook into the `LParen` + /// parsing above to call this method there unconditionally. + /// + /// Returns `true` if the rest of the arm above should be skipped, or + /// `false` if we should parse the next item as an instruction (because we + /// didn't handle the lparen here). + fn handle_if_lparen(&mut self, parser: Parser<'a>) -> Result { + // Only execute the code below if there's an `If` listed last. + let i = match self.stack.last_mut() { + Some(Level::If(i)) => i, + _ => return Ok(false), + }; + + // The first thing parsed in an `if` statement is the clause. If the + // clause starts with `then`, however, then we know to skip the clause + // and fall through to below. + if let If::Clause(if_instr) = i { + let instr = mem::replace(if_instr, Instruction::End(None)); + *i = If::Then(instr); + if !parser.peek::() { + return Ok(false); + } + } + + // All `if` statements are required to have a `then`. This is either the + // second s-expr (with or without a leading `then`) or the first s-expr + // with a leading `then`. The optionality of `then` isn't strictly what + // the text spec says but it matches wabt for now. + // + // Note that when we see the `then`, that's when we actually add the + // original `if` instruction to the stream. + if let If::Then(if_instr) = i { + let instr = mem::replace(if_instr, Instruction::End(None)); + self.instrs.push(instr); + *i = If::Else; + if parser.parse::>()?.is_some() { + self.stack.push(Level::IfArm); + return Ok(true); + } + return Ok(false); + } + + // effectively the same as the `then` parsing above + if let If::Else = i { + self.instrs.push(Instruction::Else(None)); + if parser.parse::>()?.is_some() { + if parser.is_empty() { + self.instrs.pop(); + } + self.stack.push(Level::IfArm); + return Ok(true); + } + *i = If::End; + return Ok(false); + } + + // If we made it this far then we're at `If::End` which means that there + // were too many s-expressions inside the `(if)` and we don't want to + // parse anything else. + Err(parser.error("unexpected token: too many payloads inside of `(if)`")) + } + + /// Handles parsing of a `try` statement. A `try` statement is simpler + /// than an `if` as the syntactic form is: + /// + /// ```wat + /// (try (do $do) (catch $tag $catch)) + /// ``` + /// + /// where the `do` and `catch` keywords are mandatory, even for an empty + /// $do or $catch. + /// + /// Returns `true` if the rest of the arm above should be skipped, or + /// `false` if we should parse the next item as an instruction (because we + /// didn't handle the lparen here). + fn handle_try_lparen(&mut self, parser: Parser<'a>) -> Result { + // Only execute the code below if there's a `Try` listed last. + let i = match self.stack.last_mut() { + Some(Level::Try(i)) => i, + _ => return Ok(false), + }; + + // Try statements must start with a `do` block. + if let Try::Do(try_instr) = i { + let instr = mem::replace(try_instr, Instruction::End(None)); + self.instrs.push(instr); + if parser.parse::>()?.is_some() { + // The state is advanced here only if the parse succeeds in + // order to strictly require the keyword. + *i = Try::CatchOrDelegate; + self.stack.push(Level::TryArm); + return Ok(true); + } + // We return here and continue parsing instead of raising an error + // immediately because the missing keyword will be caught more + // generally in the `Paren::Right` case in `parse`. + return Ok(false); + } + + // After a try's `do`, there are several possible kinds of handlers. + if let Try::CatchOrDelegate = i { + // `catch` may be followed by more `catch`s or `catch_all`. + if parser.parse::>()?.is_some() { + let evt = parser.parse::>()?; + self.instrs.push(Instruction::Catch(evt)); + *i = Try::Catch; + self.stack.push(Level::TryArm); + return Ok(true); + } + // `catch_all` can only come at the end and has no argument. + if parser.parse::>()?.is_some() { + self.instrs.push(Instruction::CatchAll); + *i = Try::End; + self.stack.push(Level::TryArm); + return Ok(true); + } + // `delegate` has an index, and also ends the block like `end`. + if parser.parse::>()?.is_some() { + let depth = parser.parse::>()?; + self.instrs.push(Instruction::Delegate(depth)); + *i = Try::Delegate; + match self.paren(parser)? { + Paren::Left | Paren::None => return Ok(false), + Paren::Right => return Ok(true), + } + } + return Err(parser.error("expected a `catch`, `catch_all`, or `delegate`")); + } + + if let Try::Catch = i { + if parser.parse::>()?.is_some() { + let evt = parser.parse::>()?; + self.instrs.push(Instruction::Catch(evt)); + *i = Try::Catch; + self.stack.push(Level::TryArm); + return Ok(true); + } + if parser.parse::>()?.is_some() { + self.instrs.push(Instruction::CatchAll); + *i = Try::End; + self.stack.push(Level::TryArm); + return Ok(true); + } + return Err(parser.error("unexpected items after `catch`")); + } + + Err(parser.error("unexpected token: too many payloads inside of `(try)`")) + } +} + +// TODO: document this obscenity +macro_rules! instructions { + (pub enum Instruction<'a> { + $( + $(#[$doc:meta])* + $name:ident $(($($arg:tt)*))? : [$($binary:tt)*] : $instr:tt $( | $deprecated:tt )?, + )* + }) => ( + /// A listing of all WebAssembly instructions that can be in a module + /// that this crate currently parses. + #[derive(Debug)] + #[allow(missing_docs)] + pub enum Instruction<'a> { + $( + $(#[$doc])* + $name $(( instructions!(@ty $($arg)*) ))?, + )* + } + + #[allow(non_snake_case)] + impl<'a> Parse<'a> for Instruction<'a> { + fn parse(parser: Parser<'a>) -> Result { + $( + fn $name<'a>(_parser: Parser<'a>) -> Result> { + Ok(Instruction::$name $(( + instructions!(@parse _parser $($arg)*)? + ))?) + } + )* + let parse_remainder = parser.step(|c| { + let (kw, rest) = match c.keyword() { + Some(pair) => pair, + None => return Err(c.error("expected an instruction")), + }; + match kw { + $($instr $( | $deprecated )?=> Ok(($name as fn(_) -> _, rest)),)* + _ => return Err(c.error("unknown operator or unexpected token")), + } + })?; + parse_remainder(parser) + } + } + + impl Encode for Instruction<'_> { + #[allow(non_snake_case)] + fn encode(&self, v: &mut Vec) { + match self { + $( + Instruction::$name $((instructions!(@first x $($arg)*)))? => { + fn encode<'a>($(arg: &instructions!(@ty $($arg)*),)? v: &mut Vec) { + instructions!(@encode v $($binary)*); + $(::encode(arg, v);)? + } + encode($( instructions!(@first x $($arg)*), )? v) + } + )* + } + } + } + + impl<'a> Instruction<'a> { + /// Returns the associated [`MemArg`] if one is available for this + /// instruction. + #[allow(unused_variables, non_snake_case)] + pub fn memarg_mut(&mut self) -> Option<&mut MemArg<'a>> { + match self { + $( + Instruction::$name $((instructions!(@memarg_binding a $($arg)*)))? => { + instructions!(@get_memarg a $($($arg)*)?) + } + )* + } + } + } + ); + + (@ty MemArg<$amt:tt>) => (MemArg<'a>); + (@ty LoadOrStoreLane<$amt:tt>) => (LoadOrStoreLane<'a>); + (@ty $other:ty) => ($other); + + (@first $first:ident $($t:tt)*) => ($first); + + (@parse $parser:ident MemArg<$amt:tt>) => (MemArg::parse($parser, $amt)); + (@parse $parser:ident MemArg) => (compile_error!("must specify `MemArg` default")); + (@parse $parser:ident LoadOrStoreLane<$amt:tt>) => (LoadOrStoreLane::parse($parser, $amt)); + (@parse $parser:ident LoadOrStoreLane) => (compile_error!("must specify `LoadOrStoreLane` default")); + (@parse $parser:ident $other:ty) => ($parser.parse::<$other>()); + + // simd opcodes prefixed with `0xfd` get a varuint32 encoding for their payload + (@encode $dst:ident 0xfd, $simd:tt) => ({ + $dst.push(0xfd); + ::encode(&$simd, $dst); + }); + (@encode $dst:ident $($bytes:tt)*) => ($dst.extend_from_slice(&[$($bytes)*]);); + + (@get_memarg $name:ident MemArg<$amt:tt>) => (Some($name)); + (@get_memarg $name:ident LoadOrStoreLane<$amt:tt>) => (Some(&mut $name.memarg)); + (@get_memarg $($other:tt)*) => (None); + + (@memarg_binding $name:ident MemArg<$amt:tt>) => ($name); + (@memarg_binding $name:ident LoadOrStoreLane<$amt:tt>) => ($name); + (@memarg_binding $name:ident $other:ty) => (_); +} + +instructions! { + pub enum Instruction<'a> { + Block(BlockType<'a>) : [0x02] : "block", + If(BlockType<'a>) : [0x04] : "if", + Else(Option>) : [0x05] : "else", + Loop(BlockType<'a>) : [0x03] : "loop", + End(Option>) : [0x0b] : "end", + + Unreachable : [0x00] : "unreachable", + Nop : [0x01] : "nop", + Br(Index<'a>) : [0x0c] : "br", + BrIf(Index<'a>) : [0x0d] : "br_if", + BrTable(BrTableIndices<'a>) : [0x0e] : "br_table", + Return : [0x0f] : "return", + Call(Index<'a>) : [0x10] : "call", + CallIndirect(CallIndirect<'a>) : [0x11] : "call_indirect", + + // tail-call proposal + ReturnCall(Index<'a>) : [0x12] : "return_call", + ReturnCallIndirect(CallIndirect<'a>) : [0x13] : "return_call_indirect", + + // function-references proposal + CallRef : [0x14] : "call_ref", + ReturnCallRef : [0x15] : "return_call_ref", + FuncBind(FuncBindType<'a>) : [0x16] : "func.bind", + Let(LetType<'a>) : [0x17] : "let", + + Drop : [0x1a] : "drop", + Select(SelectTypes<'a>) : [] : "select", + LocalGet(Index<'a>) : [0x20] : "local.get" | "get_local", + LocalSet(Index<'a>) : [0x21] : "local.set" | "set_local", + LocalTee(Index<'a>) : [0x22] : "local.tee" | "tee_local", + GlobalGet(Index<'a>) : [0x23] : "global.get" | "get_global", + GlobalSet(Index<'a>) : [0x24] : "global.set" | "set_global", + + TableGet(TableArg<'a>) : [0x25] : "table.get", + TableSet(TableArg<'a>) : [0x26] : "table.set", + + I32Load(MemArg<4>) : [0x28] : "i32.load", + I64Load(MemArg<8>) : [0x29] : "i64.load", + F32Load(MemArg<4>) : [0x2a] : "f32.load", + F64Load(MemArg<8>) : [0x2b] : "f64.load", + I32Load8s(MemArg<1>) : [0x2c] : "i32.load8_s", + I32Load8u(MemArg<1>) : [0x2d] : "i32.load8_u", + I32Load16s(MemArg<2>) : [0x2e] : "i32.load16_s", + I32Load16u(MemArg<2>) : [0x2f] : "i32.load16_u", + I64Load8s(MemArg<1>) : [0x30] : "i64.load8_s", + I64Load8u(MemArg<1>) : [0x31] : "i64.load8_u", + I64Load16s(MemArg<2>) : [0x32] : "i64.load16_s", + I64Load16u(MemArg<2>) : [0x33] : "i64.load16_u", + I64Load32s(MemArg<4>) : [0x34] : "i64.load32_s", + I64Load32u(MemArg<4>) : [0x35] : "i64.load32_u", + I32Store(MemArg<4>) : [0x36] : "i32.store", + I64Store(MemArg<8>) : [0x37] : "i64.store", + F32Store(MemArg<4>) : [0x38] : "f32.store", + F64Store(MemArg<8>) : [0x39] : "f64.store", + I32Store8(MemArg<1>) : [0x3a] : "i32.store8", + I32Store16(MemArg<2>) : [0x3b] : "i32.store16", + I64Store8(MemArg<1>) : [0x3c] : "i64.store8", + I64Store16(MemArg<2>) : [0x3d] : "i64.store16", + I64Store32(MemArg<4>) : [0x3e] : "i64.store32", + + // Lots of bulk memory proposal here as well + MemorySize(MemoryArg<'a>) : [0x3f] : "memory.size" | "current_memory", + MemoryGrow(MemoryArg<'a>) : [0x40] : "memory.grow" | "grow_memory", + MemoryInit(MemoryInit<'a>) : [0xfc, 0x08] : "memory.init", + MemoryCopy(MemoryCopy<'a>) : [0xfc, 0x0a] : "memory.copy", + MemoryFill(MemoryArg<'a>) : [0xfc, 0x0b] : "memory.fill", + DataDrop(Index<'a>) : [0xfc, 0x09] : "data.drop", + ElemDrop(Index<'a>) : [0xfc, 0x0d] : "elem.drop", + TableInit(TableInit<'a>) : [0xfc, 0x0c] : "table.init", + TableCopy(TableCopy<'a>) : [0xfc, 0x0e] : "table.copy", + TableFill(TableArg<'a>) : [0xfc, 0x11] : "table.fill", + TableSize(TableArg<'a>) : [0xfc, 0x10] : "table.size", + TableGrow(TableArg<'a>) : [0xfc, 0x0f] : "table.grow", + + RefNull(HeapType<'a>) : [0xd0] : "ref.null", + RefIsNull : [0xd1] : "ref.is_null", + RefFunc(Index<'a>) : [0xd2] : "ref.func", + + // function-references proposal + RefAsNonNull : [0xd3] : "ref.as_non_null", + BrOnNull(Index<'a>) : [0xd4] : "br_on_null", + BrOnNonNull(Index<'a>) : [0xd6] : "br_on_non_null", + + // gc proposal: eqref + RefEq : [0xd5] : "ref.eq", + + // gc proposal: struct + StructNew(Index<'a>) : [0xfb, 0x07] : "struct.new", + StructNewDefault(Index<'a>) : [0xfb, 0x08] : "struct.new_default", + StructGet(StructAccess<'a>) : [0xfb, 0x03] : "struct.get", + StructGetS(StructAccess<'a>) : [0xfb, 0x04] : "struct.get_s", + StructGetU(StructAccess<'a>) : [0xfb, 0x05] : "struct.get_u", + StructSet(StructAccess<'a>) : [0xfb, 0x06] : "struct.set", + + // gc proposal: array + ArrayNew(Index<'a>) : [0xfb, 0x1b] : "array.new", + ArrayNewDefault(Index<'a>) : [0xfb, 0x1c] : "array.new_default", + ArrayNewFixed(ArrayNewFixed<'a>) : [0xfb, 0x1a] : "array.new_fixed", + ArrayNewData(ArrayNewData<'a>) : [0xfb, 0x1d] : "array.new_data", + ArrayNewElem(ArrayNewElem<'a>) : [0xfb, 0x10] : "array.new_elem", + ArrayGet(Index<'a>) : [0xfb, 0x13] : "array.get", + ArrayGetS(Index<'a>) : [0xfb, 0x14] : "array.get_s", + ArrayGetU(Index<'a>) : [0xfb, 0x15] : "array.get_u", + ArraySet(Index<'a>) : [0xfb, 0x16] : "array.set", + ArrayLen(Index<'a>) : [0xfb, 0x17] : "array.len", + ArrayCopy(ArrayCopy<'a>) : [0xfb, 0x18] : "array.copy", + + // gc proposal, i31 + I31New : [0xfb, 0x20] : "i31.new", + I31GetS : [0xfb, 0x21] : "i31.get_s", + I31GetU : [0xfb, 0x22] : "i31.get_u", + + // gc proposal, concrete casting + RefTest(Index<'a>) : [0xfb, 0x44] : "ref.test", + RefCast(Index<'a>) : [0xfb, 0x45] : "ref.cast", + BrOnCast(BrOnCast<'a>) : [0xfb, 0x46] : "br_on_cast", + BrOnCastFail(BrOnCast<'a>) : [0xfb, 0x47] : "br_on_cast_fail", + + // gc proposal, heap casting + RefIsFunc : [0xfb, 0x50] : "ref.is_func", + RefIsData : [0xfb, 0x51] : "ref.is_data", + RefIsI31 : [0xfb, 0x52] : "ref.is_i31", + RefIsArray : [0xfb, 0x53] : "ref.is_array", + + RefAsFunc : [0xfb, 0x58] : "ref.as_func", + RefAsData : [0xfb, 0x59] : "ref.as_data", + RefAsI31 : [0xfb, 0x5a] : "ref.as_i31", + RefAsArray : [0xfb, 0x5b] : "ref.as_array", + + BrOnFunc(Index<'a>) : [0xfb, 0x60] : "br_on_func", + BrOnData(Index<'a>) : [0xfb, 0x61] : "br_on_data", + BrOnI31(Index<'a>) : [0xfb, 0x62] : "br_on_i31", + BrOnArray(Index<'a>) : [0xfb, 0x66] : "br_on_array", + + BrOnNonFunc(Index<'a>) : [0xfb, 0x63] : "br_on_non_func", + BrOnNonData(Index<'a>) : [0xfb, 0x64] : "br_on_non_data", + BrOnNonI31(Index<'a>) : [0xfb, 0x65] : "br_on_non_i31", + BrOnNonArray(Index<'a>) : [0xfb, 0x67] : "br_on_non_array", + + I32Const(i32) : [0x41] : "i32.const", + I64Const(i64) : [0x42] : "i64.const", + F32Const(Float32) : [0x43] : "f32.const", + F64Const(Float64) : [0x44] : "f64.const", + + I32Clz : [0x67] : "i32.clz", + I32Ctz : [0x68] : "i32.ctz", + I32Popcnt : [0x69] : "i32.popcnt", + I32Add : [0x6a] : "i32.add", + I32Sub : [0x6b] : "i32.sub", + I32Mul : [0x6c] : "i32.mul", + I32DivS : [0x6d] : "i32.div_s", + I32DivU : [0x6e] : "i32.div_u", + I32RemS : [0x6f] : "i32.rem_s", + I32RemU : [0x70] : "i32.rem_u", + I32And : [0x71] : "i32.and", + I32Or : [0x72] : "i32.or", + I32Xor : [0x73] : "i32.xor", + I32Shl : [0x74] : "i32.shl", + I32ShrS : [0x75] : "i32.shr_s", + I32ShrU : [0x76] : "i32.shr_u", + I32Rotl : [0x77] : "i32.rotl", + I32Rotr : [0x78] : "i32.rotr", + + I64Clz : [0x79] : "i64.clz", + I64Ctz : [0x7a] : "i64.ctz", + I64Popcnt : [0x7b] : "i64.popcnt", + I64Add : [0x7c] : "i64.add", + I64Sub : [0x7d] : "i64.sub", + I64Mul : [0x7e] : "i64.mul", + I64DivS : [0x7f] : "i64.div_s", + I64DivU : [0x80] : "i64.div_u", + I64RemS : [0x81] : "i64.rem_s", + I64RemU : [0x82] : "i64.rem_u", + I64And : [0x83] : "i64.and", + I64Or : [0x84] : "i64.or", + I64Xor : [0x85] : "i64.xor", + I64Shl : [0x86] : "i64.shl", + I64ShrS : [0x87] : "i64.shr_s", + I64ShrU : [0x88] : "i64.shr_u", + I64Rotl : [0x89] : "i64.rotl", + I64Rotr : [0x8a] : "i64.rotr", + + F32Abs : [0x8b] : "f32.abs", + F32Neg : [0x8c] : "f32.neg", + F32Ceil : [0x8d] : "f32.ceil", + F32Floor : [0x8e] : "f32.floor", + F32Trunc : [0x8f] : "f32.trunc", + F32Nearest : [0x90] : "f32.nearest", + F32Sqrt : [0x91] : "f32.sqrt", + F32Add : [0x92] : "f32.add", + F32Sub : [0x93] : "f32.sub", + F32Mul : [0x94] : "f32.mul", + F32Div : [0x95] : "f32.div", + F32Min : [0x96] : "f32.min", + F32Max : [0x97] : "f32.max", + F32Copysign : [0x98] : "f32.copysign", + + F64Abs : [0x99] : "f64.abs", + F64Neg : [0x9a] : "f64.neg", + F64Ceil : [0x9b] : "f64.ceil", + F64Floor : [0x9c] : "f64.floor", + F64Trunc : [0x9d] : "f64.trunc", + F64Nearest : [0x9e] : "f64.nearest", + F64Sqrt : [0x9f] : "f64.sqrt", + F64Add : [0xa0] : "f64.add", + F64Sub : [0xa1] : "f64.sub", + F64Mul : [0xa2] : "f64.mul", + F64Div : [0xa3] : "f64.div", + F64Min : [0xa4] : "f64.min", + F64Max : [0xa5] : "f64.max", + F64Copysign : [0xa6] : "f64.copysign", + + I32Eqz : [0x45] : "i32.eqz", + I32Eq : [0x46] : "i32.eq", + I32Ne : [0x47] : "i32.ne", + I32LtS : [0x48] : "i32.lt_s", + I32LtU : [0x49] : "i32.lt_u", + I32GtS : [0x4a] : "i32.gt_s", + I32GtU : [0x4b] : "i32.gt_u", + I32LeS : [0x4c] : "i32.le_s", + I32LeU : [0x4d] : "i32.le_u", + I32GeS : [0x4e] : "i32.ge_s", + I32GeU : [0x4f] : "i32.ge_u", + + I64Eqz : [0x50] : "i64.eqz", + I64Eq : [0x51] : "i64.eq", + I64Ne : [0x52] : "i64.ne", + I64LtS : [0x53] : "i64.lt_s", + I64LtU : [0x54] : "i64.lt_u", + I64GtS : [0x55] : "i64.gt_s", + I64GtU : [0x56] : "i64.gt_u", + I64LeS : [0x57] : "i64.le_s", + I64LeU : [0x58] : "i64.le_u", + I64GeS : [0x59] : "i64.ge_s", + I64GeU : [0x5a] : "i64.ge_u", + + F32Eq : [0x5b] : "f32.eq", + F32Ne : [0x5c] : "f32.ne", + F32Lt : [0x5d] : "f32.lt", + F32Gt : [0x5e] : "f32.gt", + F32Le : [0x5f] : "f32.le", + F32Ge : [0x60] : "f32.ge", + + F64Eq : [0x61] : "f64.eq", + F64Ne : [0x62] : "f64.ne", + F64Lt : [0x63] : "f64.lt", + F64Gt : [0x64] : "f64.gt", + F64Le : [0x65] : "f64.le", + F64Ge : [0x66] : "f64.ge", + + I32WrapI64 : [0xa7] : "i32.wrap_i64" | "i32.wrap/i64", + I32TruncF32S : [0xa8] : "i32.trunc_f32_s" | "i32.trunc_s/f32", + I32TruncF32U : [0xa9] : "i32.trunc_f32_u" | "i32.trunc_u/f32", + I32TruncF64S : [0xaa] : "i32.trunc_f64_s" | "i32.trunc_s/f64", + I32TruncF64U : [0xab] : "i32.trunc_f64_u" | "i32.trunc_u/f64", + I64ExtendI32S : [0xac] : "i64.extend_i32_s" | "i64.extend_s/i32", + I64ExtendI32U : [0xad] : "i64.extend_i32_u" | "i64.extend_u/i32", + I64TruncF32S : [0xae] : "i64.trunc_f32_s" | "i64.trunc_s/f32", + I64TruncF32U : [0xaf] : "i64.trunc_f32_u" | "i64.trunc_u/f32", + I64TruncF64S : [0xb0] : "i64.trunc_f64_s" | "i64.trunc_s/f64", + I64TruncF64U : [0xb1] : "i64.trunc_f64_u" | "i64.trunc_u/f64", + F32ConvertI32S : [0xb2] : "f32.convert_i32_s" | "f32.convert_s/i32", + F32ConvertI32U : [0xb3] : "f32.convert_i32_u" | "f32.convert_u/i32", + F32ConvertI64S : [0xb4] : "f32.convert_i64_s" | "f32.convert_s/i64", + F32ConvertI64U : [0xb5] : "f32.convert_i64_u" | "f32.convert_u/i64", + F32DemoteF64 : [0xb6] : "f32.demote_f64" | "f32.demote/f64", + F64ConvertI32S : [0xb7] : "f64.convert_i32_s" | "f64.convert_s/i32", + F64ConvertI32U : [0xb8] : "f64.convert_i32_u" | "f64.convert_u/i32", + F64ConvertI64S : [0xb9] : "f64.convert_i64_s" | "f64.convert_s/i64", + F64ConvertI64U : [0xba] : "f64.convert_i64_u" | "f64.convert_u/i64", + F64PromoteF32 : [0xbb] : "f64.promote_f32" | "f64.promote/f32", + I32ReinterpretF32 : [0xbc] : "i32.reinterpret_f32" | "i32.reinterpret/f32", + I64ReinterpretF64 : [0xbd] : "i64.reinterpret_f64" | "i64.reinterpret/f64", + F32ReinterpretI32 : [0xbe] : "f32.reinterpret_i32" | "f32.reinterpret/i32", + F64ReinterpretI64 : [0xbf] : "f64.reinterpret_i64" | "f64.reinterpret/i64", + + // pkru + Rdpkru : [0xf1, 0xee] : "rdpkru", + Wrpkru : [0xf1, 0xef] : "wrpkru", + + // non-trapping float to int + I32TruncSatF32S : [0xfc, 0x00] : "i32.trunc_sat_f32_s" | "i32.trunc_s:sat/f32", + I32TruncSatF32U : [0xfc, 0x01] : "i32.trunc_sat_f32_u" | "i32.trunc_u:sat/f32", + I32TruncSatF64S : [0xfc, 0x02] : "i32.trunc_sat_f64_s" | "i32.trunc_s:sat/f64", + I32TruncSatF64U : [0xfc, 0x03] : "i32.trunc_sat_f64_u" | "i32.trunc_u:sat/f64", + I64TruncSatF32S : [0xfc, 0x04] : "i64.trunc_sat_f32_s" | "i64.trunc_s:sat/f32", + I64TruncSatF32U : [0xfc, 0x05] : "i64.trunc_sat_f32_u" | "i64.trunc_u:sat/f32", + I64TruncSatF64S : [0xfc, 0x06] : "i64.trunc_sat_f64_s" | "i64.trunc_s:sat/f64", + I64TruncSatF64U : [0xfc, 0x07] : "i64.trunc_sat_f64_u" | "i64.trunc_u:sat/f64", + + // sign extension proposal + I32Extend8S : [0xc0] : "i32.extend8_s", + I32Extend16S : [0xc1] : "i32.extend16_s", + I64Extend8S : [0xc2] : "i64.extend8_s", + I64Extend16S : [0xc3] : "i64.extend16_s", + I64Extend32S : [0xc4] : "i64.extend32_s", + + // atomics proposal + MemoryAtomicNotify(MemArg<4>) : [0xfe, 0x00] : "memory.atomic.notify" | "atomic.notify", + MemoryAtomicWait32(MemArg<4>) : [0xfe, 0x01] : "memory.atomic.wait32" | "i32.atomic.wait", + MemoryAtomicWait64(MemArg<8>) : [0xfe, 0x02] : "memory.atomic.wait64" | "i64.atomic.wait", + AtomicFence : [0xfe, 0x03, 0x00] : "atomic.fence", + + I32AtomicLoad(MemArg<4>) : [0xfe, 0x10] : "i32.atomic.load", + I64AtomicLoad(MemArg<8>) : [0xfe, 0x11] : "i64.atomic.load", + I32AtomicLoad8u(MemArg<1>) : [0xfe, 0x12] : "i32.atomic.load8_u", + I32AtomicLoad16u(MemArg<2>) : [0xfe, 0x13] : "i32.atomic.load16_u", + I64AtomicLoad8u(MemArg<1>) : [0xfe, 0x14] : "i64.atomic.load8_u", + I64AtomicLoad16u(MemArg<2>) : [0xfe, 0x15] : "i64.atomic.load16_u", + I64AtomicLoad32u(MemArg<4>) : [0xfe, 0x16] : "i64.atomic.load32_u", + I32AtomicStore(MemArg<4>) : [0xfe, 0x17] : "i32.atomic.store", + I64AtomicStore(MemArg<8>) : [0xfe, 0x18] : "i64.atomic.store", + I32AtomicStore8(MemArg<1>) : [0xfe, 0x19] : "i32.atomic.store8", + I32AtomicStore16(MemArg<2>) : [0xfe, 0x1a] : "i32.atomic.store16", + I64AtomicStore8(MemArg<1>) : [0xfe, 0x1b] : "i64.atomic.store8", + I64AtomicStore16(MemArg<2>) : [0xfe, 0x1c] : "i64.atomic.store16", + I64AtomicStore32(MemArg<4>) : [0xfe, 0x1d] : "i64.atomic.store32", + + I32AtomicRmwAdd(MemArg<4>) : [0xfe, 0x1e] : "i32.atomic.rmw.add", + I64AtomicRmwAdd(MemArg<8>) : [0xfe, 0x1f] : "i64.atomic.rmw.add", + I32AtomicRmw8AddU(MemArg<1>) : [0xfe, 0x20] : "i32.atomic.rmw8.add_u", + I32AtomicRmw16AddU(MemArg<2>) : [0xfe, 0x21] : "i32.atomic.rmw16.add_u", + I64AtomicRmw8AddU(MemArg<1>) : [0xfe, 0x22] : "i64.atomic.rmw8.add_u", + I64AtomicRmw16AddU(MemArg<2>) : [0xfe, 0x23] : "i64.atomic.rmw16.add_u", + I64AtomicRmw32AddU(MemArg<4>) : [0xfe, 0x24] : "i64.atomic.rmw32.add_u", + + I32AtomicRmwSub(MemArg<4>) : [0xfe, 0x25] : "i32.atomic.rmw.sub", + I64AtomicRmwSub(MemArg<8>) : [0xfe, 0x26] : "i64.atomic.rmw.sub", + I32AtomicRmw8SubU(MemArg<1>) : [0xfe, 0x27] : "i32.atomic.rmw8.sub_u", + I32AtomicRmw16SubU(MemArg<2>) : [0xfe, 0x28] : "i32.atomic.rmw16.sub_u", + I64AtomicRmw8SubU(MemArg<1>) : [0xfe, 0x29] : "i64.atomic.rmw8.sub_u", + I64AtomicRmw16SubU(MemArg<2>) : [0xfe, 0x2a] : "i64.atomic.rmw16.sub_u", + I64AtomicRmw32SubU(MemArg<4>) : [0xfe, 0x2b] : "i64.atomic.rmw32.sub_u", + + I32AtomicRmwAnd(MemArg<4>) : [0xfe, 0x2c] : "i32.atomic.rmw.and", + I64AtomicRmwAnd(MemArg<8>) : [0xfe, 0x2d] : "i64.atomic.rmw.and", + I32AtomicRmw8AndU(MemArg<1>) : [0xfe, 0x2e] : "i32.atomic.rmw8.and_u", + I32AtomicRmw16AndU(MemArg<2>) : [0xfe, 0x2f] : "i32.atomic.rmw16.and_u", + I64AtomicRmw8AndU(MemArg<1>) : [0xfe, 0x30] : "i64.atomic.rmw8.and_u", + I64AtomicRmw16AndU(MemArg<2>) : [0xfe, 0x31] : "i64.atomic.rmw16.and_u", + I64AtomicRmw32AndU(MemArg<4>) : [0xfe, 0x32] : "i64.atomic.rmw32.and_u", + + I32AtomicRmwOr(MemArg<4>) : [0xfe, 0x33] : "i32.atomic.rmw.or", + I64AtomicRmwOr(MemArg<8>) : [0xfe, 0x34] : "i64.atomic.rmw.or", + I32AtomicRmw8OrU(MemArg<1>) : [0xfe, 0x35] : "i32.atomic.rmw8.or_u", + I32AtomicRmw16OrU(MemArg<2>) : [0xfe, 0x36] : "i32.atomic.rmw16.or_u", + I64AtomicRmw8OrU(MemArg<1>) : [0xfe, 0x37] : "i64.atomic.rmw8.or_u", + I64AtomicRmw16OrU(MemArg<2>) : [0xfe, 0x38] : "i64.atomic.rmw16.or_u", + I64AtomicRmw32OrU(MemArg<4>) : [0xfe, 0x39] : "i64.atomic.rmw32.or_u", + + I32AtomicRmwXor(MemArg<4>) : [0xfe, 0x3a] : "i32.atomic.rmw.xor", + I64AtomicRmwXor(MemArg<8>) : [0xfe, 0x3b] : "i64.atomic.rmw.xor", + I32AtomicRmw8XorU(MemArg<1>) : [0xfe, 0x3c] : "i32.atomic.rmw8.xor_u", + I32AtomicRmw16XorU(MemArg<2>) : [0xfe, 0x3d] : "i32.atomic.rmw16.xor_u", + I64AtomicRmw8XorU(MemArg<1>) : [0xfe, 0x3e] : "i64.atomic.rmw8.xor_u", + I64AtomicRmw16XorU(MemArg<2>) : [0xfe, 0x3f] : "i64.atomic.rmw16.xor_u", + I64AtomicRmw32XorU(MemArg<4>) : [0xfe, 0x40] : "i64.atomic.rmw32.xor_u", + + I32AtomicRmwXchg(MemArg<4>) : [0xfe, 0x41] : "i32.atomic.rmw.xchg", + I64AtomicRmwXchg(MemArg<8>) : [0xfe, 0x42] : "i64.atomic.rmw.xchg", + I32AtomicRmw8XchgU(MemArg<1>) : [0xfe, 0x43] : "i32.atomic.rmw8.xchg_u", + I32AtomicRmw16XchgU(MemArg<2>) : [0xfe, 0x44] : "i32.atomic.rmw16.xchg_u", + I64AtomicRmw8XchgU(MemArg<1>) : [0xfe, 0x45] : "i64.atomic.rmw8.xchg_u", + I64AtomicRmw16XchgU(MemArg<2>) : [0xfe, 0x46] : "i64.atomic.rmw16.xchg_u", + I64AtomicRmw32XchgU(MemArg<4>) : [0xfe, 0x47] : "i64.atomic.rmw32.xchg_u", + + I32AtomicRmwCmpxchg(MemArg<4>) : [0xfe, 0x48] : "i32.atomic.rmw.cmpxchg", + I64AtomicRmwCmpxchg(MemArg<8>) : [0xfe, 0x49] : "i64.atomic.rmw.cmpxchg", + I32AtomicRmw8CmpxchgU(MemArg<1>) : [0xfe, 0x4a] : "i32.atomic.rmw8.cmpxchg_u", + I32AtomicRmw16CmpxchgU(MemArg<2>) : [0xfe, 0x4b] : "i32.atomic.rmw16.cmpxchg_u", + I64AtomicRmw8CmpxchgU(MemArg<1>) : [0xfe, 0x4c] : "i64.atomic.rmw8.cmpxchg_u", + I64AtomicRmw16CmpxchgU(MemArg<2>) : [0xfe, 0x4d] : "i64.atomic.rmw16.cmpxchg_u", + I64AtomicRmw32CmpxchgU(MemArg<4>) : [0xfe, 0x4e] : "i64.atomic.rmw32.cmpxchg_u", + + // proposal: simd + // + // https://webassembly.github.io/simd/core/binary/instructions.html + V128Load(MemArg<16>) : [0xfd, 0] : "v128.load", + V128Load8x8S(MemArg<8>) : [0xfd, 1] : "v128.load8x8_s", + V128Load8x8U(MemArg<8>) : [0xfd, 2] : "v128.load8x8_u", + V128Load16x4S(MemArg<8>) : [0xfd, 3] : "v128.load16x4_s", + V128Load16x4U(MemArg<8>) : [0xfd, 4] : "v128.load16x4_u", + V128Load32x2S(MemArg<8>) : [0xfd, 5] : "v128.load32x2_s", + V128Load32x2U(MemArg<8>) : [0xfd, 6] : "v128.load32x2_u", + V128Load8Splat(MemArg<1>) : [0xfd, 7] : "v128.load8_splat", + V128Load16Splat(MemArg<2>) : [0xfd, 8] : "v128.load16_splat", + V128Load32Splat(MemArg<4>) : [0xfd, 9] : "v128.load32_splat", + V128Load64Splat(MemArg<8>) : [0xfd, 10] : "v128.load64_splat", + V128Load32Zero(MemArg<4>) : [0xfd, 92] : "v128.load32_zero", + V128Load64Zero(MemArg<8>) : [0xfd, 93] : "v128.load64_zero", + V128Store(MemArg<16>) : [0xfd, 11] : "v128.store", + + V128Load8Lane(LoadOrStoreLane<1>) : [0xfd, 84] : "v128.load8_lane", + V128Load16Lane(LoadOrStoreLane<2>) : [0xfd, 85] : "v128.load16_lane", + V128Load32Lane(LoadOrStoreLane<4>) : [0xfd, 86] : "v128.load32_lane", + V128Load64Lane(LoadOrStoreLane<8>): [0xfd, 87] : "v128.load64_lane", + V128Store8Lane(LoadOrStoreLane<1>) : [0xfd, 88] : "v128.store8_lane", + V128Store16Lane(LoadOrStoreLane<2>) : [0xfd, 89] : "v128.store16_lane", + V128Store32Lane(LoadOrStoreLane<4>) : [0xfd, 90] : "v128.store32_lane", + V128Store64Lane(LoadOrStoreLane<8>) : [0xfd, 91] : "v128.store64_lane", + + V128Const(V128Const) : [0xfd, 12] : "v128.const", + I8x16Shuffle(I8x16Shuffle) : [0xfd, 13] : "i8x16.shuffle", + + I8x16ExtractLaneS(LaneArg) : [0xfd, 21] : "i8x16.extract_lane_s", + I8x16ExtractLaneU(LaneArg) : [0xfd, 22] : "i8x16.extract_lane_u", + I8x16ReplaceLane(LaneArg) : [0xfd, 23] : "i8x16.replace_lane", + I16x8ExtractLaneS(LaneArg) : [0xfd, 24] : "i16x8.extract_lane_s", + I16x8ExtractLaneU(LaneArg) : [0xfd, 25] : "i16x8.extract_lane_u", + I16x8ReplaceLane(LaneArg) : [0xfd, 26] : "i16x8.replace_lane", + I32x4ExtractLane(LaneArg) : [0xfd, 27] : "i32x4.extract_lane", + I32x4ReplaceLane(LaneArg) : [0xfd, 28] : "i32x4.replace_lane", + I64x2ExtractLane(LaneArg) : [0xfd, 29] : "i64x2.extract_lane", + I64x2ReplaceLane(LaneArg) : [0xfd, 30] : "i64x2.replace_lane", + F32x4ExtractLane(LaneArg) : [0xfd, 31] : "f32x4.extract_lane", + F32x4ReplaceLane(LaneArg) : [0xfd, 32] : "f32x4.replace_lane", + F64x2ExtractLane(LaneArg) : [0xfd, 33] : "f64x2.extract_lane", + F64x2ReplaceLane(LaneArg) : [0xfd, 34] : "f64x2.replace_lane", + + I8x16Swizzle : [0xfd, 14] : "i8x16.swizzle", + I8x16Splat : [0xfd, 15] : "i8x16.splat", + I16x8Splat : [0xfd, 16] : "i16x8.splat", + I32x4Splat : [0xfd, 17] : "i32x4.splat", + I64x2Splat : [0xfd, 18] : "i64x2.splat", + F32x4Splat : [0xfd, 19] : "f32x4.splat", + F64x2Splat : [0xfd, 20] : "f64x2.splat", + + I8x16Eq : [0xfd, 35] : "i8x16.eq", + I8x16Ne : [0xfd, 36] : "i8x16.ne", + I8x16LtS : [0xfd, 37] : "i8x16.lt_s", + I8x16LtU : [0xfd, 38] : "i8x16.lt_u", + I8x16GtS : [0xfd, 39] : "i8x16.gt_s", + I8x16GtU : [0xfd, 40] : "i8x16.gt_u", + I8x16LeS : [0xfd, 41] : "i8x16.le_s", + I8x16LeU : [0xfd, 42] : "i8x16.le_u", + I8x16GeS : [0xfd, 43] : "i8x16.ge_s", + I8x16GeU : [0xfd, 44] : "i8x16.ge_u", + + I16x8Eq : [0xfd, 45] : "i16x8.eq", + I16x8Ne : [0xfd, 46] : "i16x8.ne", + I16x8LtS : [0xfd, 47] : "i16x8.lt_s", + I16x8LtU : [0xfd, 48] : "i16x8.lt_u", + I16x8GtS : [0xfd, 49] : "i16x8.gt_s", + I16x8GtU : [0xfd, 50] : "i16x8.gt_u", + I16x8LeS : [0xfd, 51] : "i16x8.le_s", + I16x8LeU : [0xfd, 52] : "i16x8.le_u", + I16x8GeS : [0xfd, 53] : "i16x8.ge_s", + I16x8GeU : [0xfd, 54] : "i16x8.ge_u", + + I32x4Eq : [0xfd, 55] : "i32x4.eq", + I32x4Ne : [0xfd, 56] : "i32x4.ne", + I32x4LtS : [0xfd, 57] : "i32x4.lt_s", + I32x4LtU : [0xfd, 58] : "i32x4.lt_u", + I32x4GtS : [0xfd, 59] : "i32x4.gt_s", + I32x4GtU : [0xfd, 60] : "i32x4.gt_u", + I32x4LeS : [0xfd, 61] : "i32x4.le_s", + I32x4LeU : [0xfd, 62] : "i32x4.le_u", + I32x4GeS : [0xfd, 63] : "i32x4.ge_s", + I32x4GeU : [0xfd, 64] : "i32x4.ge_u", + + I64x2Eq : [0xfd, 214] : "i64x2.eq", + I64x2Ne : [0xfd, 215] : "i64x2.ne", + I64x2LtS : [0xfd, 216] : "i64x2.lt_s", + I64x2GtS : [0xfd, 217] : "i64x2.gt_s", + I64x2LeS : [0xfd, 218] : "i64x2.le_s", + I64x2GeS : [0xfd, 219] : "i64x2.ge_s", + + F32x4Eq : [0xfd, 65] : "f32x4.eq", + F32x4Ne : [0xfd, 66] : "f32x4.ne", + F32x4Lt : [0xfd, 67] : "f32x4.lt", + F32x4Gt : [0xfd, 68] : "f32x4.gt", + F32x4Le : [0xfd, 69] : "f32x4.le", + F32x4Ge : [0xfd, 70] : "f32x4.ge", + + F64x2Eq : [0xfd, 71] : "f64x2.eq", + F64x2Ne : [0xfd, 72] : "f64x2.ne", + F64x2Lt : [0xfd, 73] : "f64x2.lt", + F64x2Gt : [0xfd, 74] : "f64x2.gt", + F64x2Le : [0xfd, 75] : "f64x2.le", + F64x2Ge : [0xfd, 76] : "f64x2.ge", + + V128Not : [0xfd, 77] : "v128.not", + V128And : [0xfd, 78] : "v128.and", + V128Andnot : [0xfd, 79] : "v128.andnot", + V128Or : [0xfd, 80] : "v128.or", + V128Xor : [0xfd, 81] : "v128.xor", + V128Bitselect : [0xfd, 82] : "v128.bitselect", + V128AnyTrue : [0xfd, 83] : "v128.any_true", + + I8x16Abs : [0xfd, 96] : "i8x16.abs", + I8x16Neg : [0xfd, 97] : "i8x16.neg", + I8x16Popcnt : [0xfd, 98] : "i8x16.popcnt", + I8x16AllTrue : [0xfd, 99] : "i8x16.all_true", + I8x16Bitmask : [0xfd, 100] : "i8x16.bitmask", + I8x16NarrowI16x8S : [0xfd, 101] : "i8x16.narrow_i16x8_s", + I8x16NarrowI16x8U : [0xfd, 102] : "i8x16.narrow_i16x8_u", + I8x16Shl : [0xfd, 107] : "i8x16.shl", + I8x16ShrS : [0xfd, 108] : "i8x16.shr_s", + I8x16ShrU : [0xfd, 109] : "i8x16.shr_u", + I8x16Add : [0xfd, 110] : "i8x16.add", + I8x16AddSatS : [0xfd, 111] : "i8x16.add_sat_s", + I8x16AddSatU : [0xfd, 112] : "i8x16.add_sat_u", + I8x16Sub : [0xfd, 113] : "i8x16.sub", + I8x16SubSatS : [0xfd, 114] : "i8x16.sub_sat_s", + I8x16SubSatU : [0xfd, 115] : "i8x16.sub_sat_u", + I8x16MinS : [0xfd, 118] : "i8x16.min_s", + I8x16MinU : [0xfd, 119] : "i8x16.min_u", + I8x16MaxS : [0xfd, 120] : "i8x16.max_s", + I8x16MaxU : [0xfd, 121] : "i8x16.max_u", + I8x16AvgrU : [0xfd, 123] : "i8x16.avgr_u", + + I16x8ExtAddPairwiseI8x16S : [0xfd, 124] : "i16x8.extadd_pairwise_i8x16_s", + I16x8ExtAddPairwiseI8x16U : [0xfd, 125] : "i16x8.extadd_pairwise_i8x16_u", + I16x8Abs : [0xfd, 128] : "i16x8.abs", + I16x8Neg : [0xfd, 129] : "i16x8.neg", + I16x8Q15MulrSatS : [0xfd, 130] : "i16x8.q15mulr_sat_s", + I16x8AllTrue : [0xfd, 131] : "i16x8.all_true", + I16x8Bitmask : [0xfd, 132] : "i16x8.bitmask", + I16x8NarrowI32x4S : [0xfd, 133] : "i16x8.narrow_i32x4_s", + I16x8NarrowI32x4U : [0xfd, 134] : "i16x8.narrow_i32x4_u", + I16x8ExtendLowI8x16S : [0xfd, 135] : "i16x8.extend_low_i8x16_s", + I16x8ExtendHighI8x16S : [0xfd, 136] : "i16x8.extend_high_i8x16_s", + I16x8ExtendLowI8x16U : [0xfd, 137] : "i16x8.extend_low_i8x16_u", + I16x8ExtendHighI8x16u : [0xfd, 138] : "i16x8.extend_high_i8x16_u", + I16x8Shl : [0xfd, 139] : "i16x8.shl", + I16x8ShrS : [0xfd, 140] : "i16x8.shr_s", + I16x8ShrU : [0xfd, 141] : "i16x8.shr_u", + I16x8Add : [0xfd, 142] : "i16x8.add", + I16x8AddSatS : [0xfd, 143] : "i16x8.add_sat_s", + I16x8AddSatU : [0xfd, 144] : "i16x8.add_sat_u", + I16x8Sub : [0xfd, 145] : "i16x8.sub", + I16x8SubSatS : [0xfd, 146] : "i16x8.sub_sat_s", + I16x8SubSatU : [0xfd, 147] : "i16x8.sub_sat_u", + I16x8Mul : [0xfd, 149] : "i16x8.mul", + I16x8MinS : [0xfd, 150] : "i16x8.min_s", + I16x8MinU : [0xfd, 151] : "i16x8.min_u", + I16x8MaxS : [0xfd, 152] : "i16x8.max_s", + I16x8MaxU : [0xfd, 153] : "i16x8.max_u", + I16x8AvgrU : [0xfd, 155] : "i16x8.avgr_u", + I16x8ExtMulLowI8x16S : [0xfd, 156] : "i16x8.extmul_low_i8x16_s", + I16x8ExtMulHighI8x16S : [0xfd, 157] : "i16x8.extmul_high_i8x16_s", + I16x8ExtMulLowI8x16U : [0xfd, 158] : "i16x8.extmul_low_i8x16_u", + I16x8ExtMulHighI8x16U : [0xfd, 159] : "i16x8.extmul_high_i8x16_u", + + I32x4ExtAddPairwiseI16x8S : [0xfd, 126] : "i32x4.extadd_pairwise_i16x8_s", + I32x4ExtAddPairwiseI16x8U : [0xfd, 127] : "i32x4.extadd_pairwise_i16x8_u", + I32x4Abs : [0xfd, 160] : "i32x4.abs", + I32x4Neg : [0xfd, 161] : "i32x4.neg", + I32x4AllTrue : [0xfd, 163] : "i32x4.all_true", + I32x4Bitmask : [0xfd, 164] : "i32x4.bitmask", + I32x4ExtendLowI16x8S : [0xfd, 167] : "i32x4.extend_low_i16x8_s", + I32x4ExtendHighI16x8S : [0xfd, 168] : "i32x4.extend_high_i16x8_s", + I32x4ExtendLowI16x8U : [0xfd, 169] : "i32x4.extend_low_i16x8_u", + I32x4ExtendHighI16x8U : [0xfd, 170] : "i32x4.extend_high_i16x8_u", + I32x4Shl : [0xfd, 171] : "i32x4.shl", + I32x4ShrS : [0xfd, 172] : "i32x4.shr_s", + I32x4ShrU : [0xfd, 173] : "i32x4.shr_u", + I32x4Add : [0xfd, 174] : "i32x4.add", + I32x4Sub : [0xfd, 177] : "i32x4.sub", + I32x4Mul : [0xfd, 181] : "i32x4.mul", + I32x4MinS : [0xfd, 182] : "i32x4.min_s", + I32x4MinU : [0xfd, 183] : "i32x4.min_u", + I32x4MaxS : [0xfd, 184] : "i32x4.max_s", + I32x4MaxU : [0xfd, 185] : "i32x4.max_u", + I32x4DotI16x8S : [0xfd, 186] : "i32x4.dot_i16x8_s", + I32x4ExtMulLowI16x8S : [0xfd, 188] : "i32x4.extmul_low_i16x8_s", + I32x4ExtMulHighI16x8S : [0xfd, 189] : "i32x4.extmul_high_i16x8_s", + I32x4ExtMulLowI16x8U : [0xfd, 190] : "i32x4.extmul_low_i16x8_u", + I32x4ExtMulHighI16x8U : [0xfd, 191] : "i32x4.extmul_high_i16x8_u", + + I64x2Abs : [0xfd, 192] : "i64x2.abs", + I64x2Neg : [0xfd, 193] : "i64x2.neg", + I64x2AllTrue : [0xfd, 195] : "i64x2.all_true", + I64x2Bitmask : [0xfd, 196] : "i64x2.bitmask", + I64x2ExtendLowI32x4S : [0xfd, 199] : "i64x2.extend_low_i32x4_s", + I64x2ExtendHighI32x4S : [0xfd, 200] : "i64x2.extend_high_i32x4_s", + I64x2ExtendLowI32x4U : [0xfd, 201] : "i64x2.extend_low_i32x4_u", + I64x2ExtendHighI32x4U : [0xfd, 202] : "i64x2.extend_high_i32x4_u", + I64x2Shl : [0xfd, 203] : "i64x2.shl", + I64x2ShrS : [0xfd, 204] : "i64x2.shr_s", + I64x2ShrU : [0xfd, 205] : "i64x2.shr_u", + I64x2Add : [0xfd, 206] : "i64x2.add", + I64x2Sub : [0xfd, 209] : "i64x2.sub", + I64x2Mul : [0xfd, 213] : "i64x2.mul", + I64x2ExtMulLowI32x4S : [0xfd, 220] : "i64x2.extmul_low_i32x4_s", + I64x2ExtMulHighI32x4S : [0xfd, 221] : "i64x2.extmul_high_i32x4_s", + I64x2ExtMulLowI32x4U : [0xfd, 222] : "i64x2.extmul_low_i32x4_u", + I64x2ExtMulHighI32x4U : [0xfd, 223] : "i64x2.extmul_high_i32x4_u", + + F32x4Ceil : [0xfd, 103] : "f32x4.ceil", + F32x4Floor : [0xfd, 104] : "f32x4.floor", + F32x4Trunc : [0xfd, 105] : "f32x4.trunc", + F32x4Nearest : [0xfd, 106] : "f32x4.nearest", + F32x4Abs : [0xfd, 224] : "f32x4.abs", + F32x4Neg : [0xfd, 225] : "f32x4.neg", + F32x4Sqrt : [0xfd, 227] : "f32x4.sqrt", + F32x4Add : [0xfd, 228] : "f32x4.add", + F32x4Sub : [0xfd, 229] : "f32x4.sub", + F32x4Mul : [0xfd, 230] : "f32x4.mul", + F32x4Div : [0xfd, 231] : "f32x4.div", + F32x4Min : [0xfd, 232] : "f32x4.min", + F32x4Max : [0xfd, 233] : "f32x4.max", + F32x4PMin : [0xfd, 234] : "f32x4.pmin", + F32x4PMax : [0xfd, 235] : "f32x4.pmax", + + F64x2Ceil : [0xfd, 116] : "f64x2.ceil", + F64x2Floor : [0xfd, 117] : "f64x2.floor", + F64x2Trunc : [0xfd, 122] : "f64x2.trunc", + F64x2Nearest : [0xfd, 148] : "f64x2.nearest", + F64x2Abs : [0xfd, 236] : "f64x2.abs", + F64x2Neg : [0xfd, 237] : "f64x2.neg", + F64x2Sqrt : [0xfd, 239] : "f64x2.sqrt", + F64x2Add : [0xfd, 240] : "f64x2.add", + F64x2Sub : [0xfd, 241] : "f64x2.sub", + F64x2Mul : [0xfd, 242] : "f64x2.mul", + F64x2Div : [0xfd, 243] : "f64x2.div", + F64x2Min : [0xfd, 244] : "f64x2.min", + F64x2Max : [0xfd, 245] : "f64x2.max", + F64x2PMin : [0xfd, 246] : "f64x2.pmin", + F64x2PMax : [0xfd, 247] : "f64x2.pmax", + + I32x4TruncSatF32x4S : [0xfd, 248] : "i32x4.trunc_sat_f32x4_s", + I32x4TruncSatF32x4U : [0xfd, 249] : "i32x4.trunc_sat_f32x4_u", + F32x4ConvertI32x4S : [0xfd, 250] : "f32x4.convert_i32x4_s", + F32x4ConvertI32x4U : [0xfd, 251] : "f32x4.convert_i32x4_u", + I32x4TruncSatF64x2SZero : [0xfd, 252] : "i32x4.trunc_sat_f64x2_s_zero", + I32x4TruncSatF64x2UZero : [0xfd, 253] : "i32x4.trunc_sat_f64x2_u_zero", + F64x2ConvertLowI32x4S : [0xfd, 254] : "f64x2.convert_low_i32x4_s", + F64x2ConvertLowI32x4U : [0xfd, 255] : "f64x2.convert_low_i32x4_u", + F32x4DemoteF64x2Zero : [0xfd, 94] : "f32x4.demote_f64x2_zero", + F64x2PromoteLowF32x4 : [0xfd, 95] : "f64x2.promote_low_f32x4", + + // Exception handling proposal + Try(BlockType<'a>) : [0x06] : "try", + Catch(Index<'a>) : [0x07] : "catch", + Throw(Index<'a>) : [0x08] : "throw", + Rethrow(Index<'a>) : [0x09] : "rethrow", + Delegate(Index<'a>) : [0x18] : "delegate", + CatchAll : [0x19] : "catch_all", + + // Relaxed SIMD proposal + I8x16RelaxedSwizzle : [0xfd, 0xa2]: "i8x16.relaxed_swizzle", + I32x4RelaxedTruncSatF32x4S : [0xfd, 0xa5]: "i32x4.relaxed_trunc_f32x4_s", + I32x4RelaxedTruncSatF32x4U : [0xfd, 0xa6]: "i32x4.relaxed_trunc_f32x4_u", + I32x4RelaxedTruncSatF64x2SZero : [0xfd, 0xc5]: "i32x4.relaxed_trunc_f64x2_s_zero", + I32x4RelaxedTruncSatF64x2UZero : [0xfd, 0xc6]: "i32x4.relaxed_trunc_f64x2_u_zero", + F32x4Fma : [0xfd, 0xaf]: "f32x4.fma", + F32x4Fms : [0xfd, 0xb0]: "f32x4.fms", + F64x4Fma : [0xfd, 0xcf]: "f64x2.fma", + F64x4Fms : [0xfd, 0xd0]: "f64x2.fms", + I8x16LaneSelect : [0xfd, 0xb2]: "i8x16.laneselect", + I16x8LaneSelect : [0xfd, 0xb3]: "i16x8.laneselect", + I32x4LaneSelect : [0xfd, 0xd2]: "i32x4.laneselect", + I64x2LaneSelect : [0xfd, 0xd3]: "i64x2.laneselect", + F32x4RelaxedMin : [0xfd, 0xb4]: "f32x4.relaxed_min", + F32x4RelaxedMax : [0xfd, 0xe2]: "f32x4.relaxed_max", + F64x2RelaxedMin : [0xfd, 0xd4]: "f64x2.relaxed_min", + F64x2RelaxedMax : [0xfd, 0xee]: "f64x2.relaxed_max", + } +} + +impl<'a> Instruction<'a> { + pub(crate) fn needs_data_count(&self) -> bool { + match self { + Instruction::MemoryInit(_) + | Instruction::DataDrop(_) + | Instruction::ArrayNewData(_) => true, + _ => false, + } + } +} + +/// Extra information associated with block-related instructions. +/// +/// This is used to label blocks and also annotate what types are expected for +/// the block. +#[derive(Debug)] +#[allow(missing_docs)] +pub struct BlockType<'a> { + pub label: Option>, + pub label_name: Option>, + pub ty: TypeUse<'a, FunctionType<'a>>, +} + +impl<'a> Parse<'a> for BlockType<'a> { + fn parse(parser: Parser<'a>) -> Result { + Ok(BlockType { + label: parser.parse()?, + label_name: parser.parse()?, + ty: parser + .parse::>>()? + .into(), + }) + } +} + +/// Extra information associated with the func.bind instruction. +#[derive(Debug)] +#[allow(missing_docs)] +pub struct FuncBindType<'a> { + pub ty: TypeUse<'a, FunctionType<'a>>, +} + +impl<'a> Parse<'a> for FuncBindType<'a> { + fn parse(parser: Parser<'a>) -> Result { + Ok(FuncBindType { + ty: parser + .parse::>>()? + .into(), + }) + } +} + +/// Extra information associated with the let instruction. +#[derive(Debug)] +#[allow(missing_docs)] +pub struct LetType<'a> { + pub block: BlockType<'a>, + pub locals: Vec>, +} + +impl<'a> Parse<'a> for LetType<'a> { + fn parse(parser: Parser<'a>) -> Result { + Ok(LetType { + block: parser.parse()?, + locals: Local::parse_remainder(parser)?, + }) + } +} + +/// Extra information associated with the `br_table` instruction. +#[allow(missing_docs)] +#[derive(Debug)] +pub struct BrTableIndices<'a> { + pub labels: Vec>, + pub default: Index<'a>, +} + +impl<'a> Parse<'a> for BrTableIndices<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut labels = vec![parser.parse()?]; + while parser.peek::() { + labels.push(parser.parse()?); + } + let default = labels.pop().unwrap(); + Ok(BrTableIndices { labels, default }) + } +} + +/// Payload for lane-related instructions. Unsigned with no + prefix. +#[derive(Debug)] +pub struct LaneArg { + /// The lane argument. + pub lane: u8, +} + +impl<'a> Parse<'a> for LaneArg { + fn parse(parser: Parser<'a>) -> Result { + let lane = parser.step(|c| { + if let Some((i, rest)) = c.integer() { + if i.sign() == None { + let (src, radix) = i.val(); + let val = u8::from_str_radix(src, radix) + .map_err(|_| c.error("malformed lane index"))?; + Ok((val, rest)) + } else { + Err(c.error("unexpected token")) + } + } else { + Err(c.error("expected a lane index")) + } + })?; + Ok(LaneArg { lane }) + } +} + +/// Payload for memory-related instructions indicating offset/alignment of +/// memory accesses. +#[derive(Debug)] +pub struct MemArg<'a> { + /// The alignment of this access. + /// + /// This is not stored as a log, this is the actual alignment (e.g. 1, 2, 4, + /// 8, etc). + pub align: u32, + /// The offset, in bytes of this access. + pub offset: u64, + /// The memory index we're accessing + pub memory: Index<'a>, +} + +impl<'a> MemArg<'a> { + fn parse(parser: Parser<'a>, default_align: u32) -> Result { + fn parse_field( + name: &str, + parser: Parser<'_>, + f: impl FnOnce(Cursor<'_>, &str, u32) -> Result, + ) -> Result> { + parser.step(|c| { + let (kw, rest) = match c.keyword() { + Some(p) => p, + None => return Ok((None, c)), + }; + if !kw.starts_with(name) { + return Ok((None, c)); + } + let kw = &kw[name.len()..]; + if !kw.starts_with('=') { + return Ok((None, c)); + } + let num = &kw[1..]; + let num = if let Some(stripped) = num.strip_prefix("0x") { + f(c, stripped, 16)? + } else { + f(c, num, 10)? + }; + + Ok((Some(num), rest)) + }) + } + + fn parse_u32(name: &str, parser: Parser<'_>) -> Result> { + parse_field(name, parser, |c, num, radix| { + u32::from_str_radix(num, radix).map_err(|_| c.error("i32 constant out of range")) + }) + } + + fn parse_u64(name: &str, parser: Parser<'_>) -> Result> { + parse_field(name, parser, |c, num, radix| { + u64::from_str_radix(num, radix).map_err(|_| c.error("i64 constant out of range")) + }) + } + + let memory = parser + .parse::>()? + .unwrap_or_else(|| Index::Num(0, parser.prev_span())); + let offset = parse_u64("offset", parser)?.unwrap_or(0); + let align = match parse_u32("align", parser)? { + Some(n) if !n.is_power_of_two() => { + return Err(parser.error("alignment must be a power of two")) + } + n => n.unwrap_or(default_align), + }; + + Ok(MemArg { + offset, + align, + memory, + }) + } +} + +/// Extra data associated with the `loadN_lane` and `storeN_lane` instructions. +#[derive(Debug)] +pub struct LoadOrStoreLane<'a> { + /// The memory argument for this instruction. + pub memarg: MemArg<'a>, + /// The lane argument for this instruction. + pub lane: LaneArg, +} + +impl<'a> LoadOrStoreLane<'a> { + fn parse(parser: Parser<'a>, default_align: u32) -> Result { + // This is sort of funky. The first integer we see could be the lane + // index, but it could also be the memory index. To determine what it is + // then if we see a second integer we need to look further. + let has_memarg = parser.step(|c| match c.integer() { + Some((_, after_int)) => { + // Two integers in a row? That means that the first one is the + // memory index and the second must be the lane index. + if after_int.integer().is_some() { + return Ok((true, c)); + } + + // If the first integer is trailed by `offset=...` or + // `align=...` then this is definitely a memarg. + if let Some((kw, _)) = after_int.keyword() { + if kw.starts_with("offset=") || kw.starts_with("align=") { + return Ok((true, c)); + } + } + + // Otherwise the first integer was trailed by something that + // didn't look like a memarg, so this must be the lane index. + Ok((false, c)) + } + + // Not an integer here? That must mean that this must be the memarg + // first followed by the trailing index. + None => Ok((true, c)), + })?; + Ok(LoadOrStoreLane { + memarg: if has_memarg { + MemArg::parse(parser, default_align)? + } else { + MemArg { + align: default_align, + offset: 0, + memory: Index::Num(0, parser.prev_span()), + } + }, + lane: LaneArg::parse(parser)?, + }) + } +} + +/// Extra data associated with the `call_indirect` instruction. +#[derive(Debug)] +pub struct CallIndirect<'a> { + /// The table that this call is going to be indexing. + pub table: Index<'a>, + /// Type type signature that this `call_indirect` instruction is using. + pub ty: TypeUse<'a, FunctionType<'a>>, +} + +impl<'a> Parse<'a> for CallIndirect<'a> { + fn parse(parser: Parser<'a>) -> Result { + let prev_span = parser.prev_span(); + let table: Option<_> = parser.parse()?; + let ty = parser.parse::>>()?; + Ok(CallIndirect { + table: table.unwrap_or(Index::Num(0, prev_span)), + ty: ty.into(), + }) + } +} + +/// Extra data associated with the `table.init` instruction +#[derive(Debug)] +pub struct TableInit<'a> { + /// The index of the table we're copying into. + pub table: Index<'a>, + /// The index of the element segment we're copying into a table. + pub elem: Index<'a>, +} + +impl<'a> Parse<'a> for TableInit<'a> { + fn parse(parser: Parser<'a>) -> Result { + let prev_span = parser.prev_span(); + let (elem, table) = if parser.peek2::() { + let table = parser.parse()?; + (parser.parse()?, table) + } else { + (parser.parse()?, Index::Num(0, prev_span)) + }; + Ok(TableInit { table, elem }) + } +} + +/// Extra data associated with the `table.copy` instruction. +#[derive(Debug)] +pub struct TableCopy<'a> { + /// The index of the destination table to copy into. + pub dst: Index<'a>, + /// The index of the source table to copy from. + pub src: Index<'a>, +} + +impl<'a> Parse<'a> for TableCopy<'a> { + fn parse(parser: Parser<'a>) -> Result { + let (dst, src) = match parser.parse::>()? { + Some(dst) => (dst, parser.parse()?), + None => ( + Index::Num(0, parser.prev_span()), + Index::Num(0, parser.prev_span()), + ), + }; + Ok(TableCopy { dst, src }) + } +} + +/// Extra data associated with unary table instructions. +#[derive(Debug)] +pub struct TableArg<'a> { + /// The index of the table argument. + pub dst: Index<'a>, +} + +impl<'a> Parse<'a> for TableArg<'a> { + fn parse(parser: Parser<'a>) -> Result { + let dst = if let Some(dst) = parser.parse()? { + dst + } else { + Index::Num(0, parser.prev_span()) + }; + Ok(TableArg { dst }) + } +} + +/// Extra data associated with unary memory instructions. +#[derive(Debug)] +pub struct MemoryArg<'a> { + /// The index of the memory space. + pub mem: Index<'a>, +} + +impl<'a> Parse<'a> for MemoryArg<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mem = if let Some(mem) = parser.parse()? { + mem + } else { + Index::Num(0, parser.prev_span()) + }; + Ok(MemoryArg { mem }) + } +} + +/// Extra data associated with the `memory.init` instruction +#[derive(Debug)] +pub struct MemoryInit<'a> { + /// The index of the data segment we're copying into memory. + pub data: Index<'a>, + /// The index of the memory we're copying into, + pub mem: Index<'a>, +} + +impl<'a> Parse<'a> for MemoryInit<'a> { + fn parse(parser: Parser<'a>) -> Result { + let prev_span = parser.prev_span(); + let (data, mem) = if parser.peek2::() { + let memory = parser.parse()?; + (parser.parse()?, memory) + } else { + (parser.parse()?, Index::Num(0, prev_span)) + }; + Ok(MemoryInit { data, mem }) + } +} + +/// Extra data associated with the `memory.copy` instruction +#[derive(Debug)] +pub struct MemoryCopy<'a> { + /// The index of the memory we're copying from. + pub src: Index<'a>, + /// The index of the memory we're copying to. + pub dst: Index<'a>, +} + +impl<'a> Parse<'a> for MemoryCopy<'a> { + fn parse(parser: Parser<'a>) -> Result { + let (src, dst) = match parser.parse()? { + Some(dst) => (parser.parse()?, dst), + None => ( + Index::Num(0, parser.prev_span()), + Index::Num(0, parser.prev_span()), + ), + }; + Ok(MemoryCopy { src, dst }) + } +} + +/// Extra data associated with the `struct.get/set` instructions +#[derive(Debug)] +pub struct StructAccess<'a> { + /// The index of the struct type we're accessing. + pub r#struct: Index<'a>, + /// The index of the field of the struct we're accessing + pub field: Index<'a>, +} + +impl<'a> Parse<'a> for StructAccess<'a> { + fn parse(parser: Parser<'a>) -> Result { + Ok(StructAccess { + r#struct: parser.parse()?, + field: parser.parse()?, + }) + } +} + +/// Extra data associated with the `array.copy` instruction +#[derive(Debug)] +pub struct ArrayCopy<'a> { + /// The index of the array type we're copying to. + pub dest_array: Index<'a>, + /// The index of the array type we're copying from. + pub src_array: Index<'a>, +} + +impl<'a> Parse<'a> for ArrayCopy<'a> { + fn parse(parser: Parser<'a>) -> Result { + Ok(ArrayCopy { + dest_array: parser.parse()?, + src_array: parser.parse()?, + }) + } +} + +/// Extra data associated with the `array.new_fixed` instruction +#[derive(Debug)] +pub struct ArrayNewFixed<'a> { + /// The index of the array type we're accessing. + pub array: Index<'a>, + /// The amount of values to initialize the array with. + pub length: u32, +} + +impl<'a> Parse<'a> for ArrayNewFixed<'a> { + fn parse(parser: Parser<'a>) -> Result { + Ok(ArrayNewFixed { + array: parser.parse()?, + length: parser.parse()?, + }) + } +} + +/// Extra data associated with the `array.new_data` instruction +#[derive(Debug)] +pub struct ArrayNewData<'a> { + /// The index of the array type we're accessing. + pub array: Index<'a>, + /// The data segment to initialize from. + pub data_idx: Index<'a>, +} + +impl<'a> Parse<'a> for ArrayNewData<'a> { + fn parse(parser: Parser<'a>) -> Result { + Ok(ArrayNewData { + array: parser.parse()?, + data_idx: parser.parse()?, + }) + } +} + +/// Extra data associated with the `array.new_elem` instruction +#[derive(Debug)] +pub struct ArrayNewElem<'a> { + /// The index of the array type we're accessing. + pub array: Index<'a>, + /// The elem segment to initialize from. + pub elem_idx: Index<'a>, +} + +impl<'a> Parse<'a> for ArrayNewElem<'a> { + fn parse(parser: Parser<'a>) -> Result { + Ok(ArrayNewElem { + array: parser.parse()?, + elem_idx: parser.parse()?, + }) + } +} + +/// Extra data associated with the `br_on_cast` instruction +#[derive(Debug)] +pub struct BrOnCast<'a> { + /// The label to branch to. + pub label: Index<'a>, + /// The index of the type we're casting. + pub r#type: Index<'a>, +} + +impl<'a> Parse<'a> for BrOnCast<'a> { + fn parse(parser: Parser<'a>) -> Result { + Ok(BrOnCast { + label: parser.parse()?, + r#type: parser.parse()?, + }) + } +} + +/// Different ways to specify a `v128.const` instruction +#[derive(Debug)] +#[rustfmt::skip] +#[allow(missing_docs)] +pub enum V128Const { + I8x16([i8; 16]), + I16x8([i16; 8]), + I32x4([i32; 4]), + I64x2([i64; 2]), + F32x4([Float32; 4]), + F64x2([Float64; 2]), +} + +impl V128Const { + /// Returns the raw little-ended byte sequence used to represent this + /// `v128` constant` + /// + /// This is typically suitable for encoding as the payload of the + /// `v128.const` instruction. + #[rustfmt::skip] + pub fn to_le_bytes(&self) -> [u8; 16] { + match self { + V128Const::I8x16(arr) => [ + arr[0] as u8, + arr[1] as u8, + arr[2] as u8, + arr[3] as u8, + arr[4] as u8, + arr[5] as u8, + arr[6] as u8, + arr[7] as u8, + arr[8] as u8, + arr[9] as u8, + arr[10] as u8, + arr[11] as u8, + arr[12] as u8, + arr[13] as u8, + arr[14] as u8, + arr[15] as u8, + ], + V128Const::I16x8(arr) => { + let a1 = arr[0].to_le_bytes(); + let a2 = arr[1].to_le_bytes(); + let a3 = arr[2].to_le_bytes(); + let a4 = arr[3].to_le_bytes(); + let a5 = arr[4].to_le_bytes(); + let a6 = arr[5].to_le_bytes(); + let a7 = arr[6].to_le_bytes(); + let a8 = arr[7].to_le_bytes(); + [ + a1[0], a1[1], + a2[0], a2[1], + a3[0], a3[1], + a4[0], a4[1], + a5[0], a5[1], + a6[0], a6[1], + a7[0], a7[1], + a8[0], a8[1], + ] + } + V128Const::I32x4(arr) => { + let a1 = arr[0].to_le_bytes(); + let a2 = arr[1].to_le_bytes(); + let a3 = arr[2].to_le_bytes(); + let a4 = arr[3].to_le_bytes(); + [ + a1[0], a1[1], a1[2], a1[3], + a2[0], a2[1], a2[2], a2[3], + a3[0], a3[1], a3[2], a3[3], + a4[0], a4[1], a4[2], a4[3], + ] + } + V128Const::I64x2(arr) => { + let a1 = arr[0].to_le_bytes(); + let a2 = arr[1].to_le_bytes(); + [ + a1[0], a1[1], a1[2], a1[3], a1[4], a1[5], a1[6], a1[7], + a2[0], a2[1], a2[2], a2[3], a2[4], a2[5], a2[6], a2[7], + ] + } + V128Const::F32x4(arr) => { + let a1 = arr[0].bits.to_le_bytes(); + let a2 = arr[1].bits.to_le_bytes(); + let a3 = arr[2].bits.to_le_bytes(); + let a4 = arr[3].bits.to_le_bytes(); + [ + a1[0], a1[1], a1[2], a1[3], + a2[0], a2[1], a2[2], a2[3], + a3[0], a3[1], a3[2], a3[3], + a4[0], a4[1], a4[2], a4[3], + ] + } + V128Const::F64x2(arr) => { + let a1 = arr[0].bits.to_le_bytes(); + let a2 = arr[1].bits.to_le_bytes(); + [ + a1[0], a1[1], a1[2], a1[3], a1[4], a1[5], a1[6], a1[7], + a2[0], a2[1], a2[2], a2[3], a2[4], a2[5], a2[6], a2[7], + ] + } + } + } +} + +impl<'a> Parse<'a> for V128Const { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + Ok(V128Const::I8x16([ + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + ])) + } else if l.peek::() { + parser.parse::()?; + Ok(V128Const::I16x8([ + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + ])) + } else if l.peek::() { + parser.parse::()?; + Ok(V128Const::I32x4([ + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + ])) + } else if l.peek::() { + parser.parse::()?; + Ok(V128Const::I64x2([parser.parse()?, parser.parse()?])) + } else if l.peek::() { + parser.parse::()?; + Ok(V128Const::F32x4([ + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + ])) + } else if l.peek::() { + parser.parse::()?; + Ok(V128Const::F64x2([parser.parse()?, parser.parse()?])) + } else { + Err(l.error()) + } + } +} + +/// Lanes being shuffled in the `i8x16.shuffle` instruction +#[derive(Debug)] +pub struct I8x16Shuffle { + #[allow(missing_docs)] + pub lanes: [u8; 16], +} + +impl<'a> Parse<'a> for I8x16Shuffle { + fn parse(parser: Parser<'a>) -> Result { + Ok(I8x16Shuffle { + lanes: [ + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + ], + }) + } +} + +/// Payload of the `select` instructions +#[derive(Debug)] +pub struct SelectTypes<'a> { + #[allow(missing_docs)] + pub tys: Option>>, +} + +impl<'a> Parse<'a> for SelectTypes<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut tys = None; + while parser.peek2::() { + let mut list = Vec::new(); + parser.parens(|p| { + p.parse::()?; + while !p.is_empty() { + list.push(p.parse()?); + } + Ok(()) + })?; + tys = Some(list); + } + Ok(SelectTypes { tys }) + } +} diff --git a/crates/wastlhw/src/core/func.rs b/crates/wastlhw/src/core/func.rs new file mode 100644 index 000000000..84abdf857 --- /dev/null +++ b/crates/wastlhw/src/core/func.rs @@ -0,0 +1,121 @@ +use crate::core::*; +use crate::kw; +use crate::parser::{Parse, Parser, Result}; +use crate::token::{Id, NameAnnotation, Span}; + +/// A WebAssembly function to be inserted into a module. +/// +/// This is a member of both the function and code sections. +#[derive(Debug)] +pub struct Func<'a> { + /// Where this `func` was defined. + pub span: Span, + /// An identifier that this function is resolved with (optionally) for name + /// resolution. + pub id: Option>, + /// An optional name for this function stored in the custom `name` section. + pub name: Option>, + /// If present, inline export annotations which indicate names this + /// definition should be exported under. + pub exports: InlineExport<'a>, + /// What kind of function this is, be it an inline-defined or imported + /// function. + pub kind: FuncKind<'a>, + /// The type that this function will have. + pub ty: TypeUse<'a, FunctionType<'a>>, +} + +/// Possible ways to define a function in the text format. +#[derive(Debug)] +pub enum FuncKind<'a> { + /// A function which is actually defined as an import, such as: + /// + /// ```text + /// (func (type 3) (import "foo" "bar")) + /// ``` + Import(InlineImport<'a>), + + /// Almost all functions, those defined inline in a wasm module. + Inline { + /// The list of locals, if any, for this function. + locals: Vec>, + + /// The instructions of the function. + expression: Expression<'a>, + }, +} + +impl<'a> Parse<'a> for Func<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let id = parser.parse()?; + let name = parser.parse()?; + let exports = parser.parse()?; + + let (ty, kind) = if let Some(import) = parser.parse()? { + (parser.parse()?, FuncKind::Import(import)) + } else { + let ty = parser.parse()?; + let locals = Local::parse_remainder(parser)?; + ( + ty, + FuncKind::Inline { + locals, + expression: parser.parse()?, + }, + ) + }; + + Ok(Func { + span, + id, + name, + exports, + ty, + kind, + }) + } +} + +/// A local for a `func` or `let` instruction. +/// +/// Each local has an optional identifier for name resolution, an optional name +/// for the custom `name` section, and a value type. +#[derive(Debug)] +pub struct Local<'a> { + /// An identifier that this local is resolved with (optionally) for name + /// resolution. + pub id: Option>, + /// An optional name for this local stored in the custom `name` section. + pub name: Option>, + /// The value type of this local. + pub ty: ValType<'a>, +} + +impl<'a> Local<'a> { + pub(crate) fn parse_remainder(parser: Parser<'a>) -> Result>> { + let mut locals = Vec::new(); + while parser.peek2::() { + parser.parens(|p| { + p.parse::()?; + if p.is_empty() { + return Ok(()); + } + let id: Option<_> = p.parse()?; + let name: Option<_> = p.parse()?; + let ty = p.parse()?; + let parse_more = id.is_none() && name.is_none(); + locals.push(Local { id, name, ty }); + while parse_more && !p.is_empty() { + locals.push(Local { + id: None, + name: None, + ty: p.parse()?, + }); + } + Ok(()) + })?; + } + Ok(locals) + } +} diff --git a/crates/wastlhw/src/core/global.rs b/crates/wastlhw/src/core/global.rs new file mode 100644 index 000000000..b8ce287fd --- /dev/null +++ b/crates/wastlhw/src/core/global.rs @@ -0,0 +1,59 @@ +use crate::core::*; +use crate::kw; +use crate::parser::{Parse, Parser, Result}; +use crate::token::{Id, NameAnnotation, Span}; + +/// A WebAssembly global in a module +#[derive(Debug)] +pub struct Global<'a> { + /// Where this `global` was defined. + pub span: Span, + /// An optional name to reference this global by + pub id: Option>, + /// An optional name for this function stored in the custom `name` section. + pub name: Option>, + /// If present, inline export annotations which indicate names this + /// definition should be exported under. + pub exports: InlineExport<'a>, + /// The type of this global, both its value type and whether it's mutable. + pub ty: GlobalType<'a>, + /// What kind of global this defined as. + pub kind: GlobalKind<'a>, +} + +/// Different kinds of globals that can be defined in a module. +#[derive(Debug)] +pub enum GlobalKind<'a> { + /// A global which is actually defined as an import, such as: + /// + /// ```text + /// (global i32 (import "foo" "bar")) + /// ``` + Import(InlineImport<'a>), + + /// A global defined inline in the module itself + Inline(Expression<'a>), +} + +impl<'a> Parse<'a> for Global<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let id = parser.parse()?; + let name = parser.parse()?; + let exports = parser.parse()?; + + let (ty, kind) = if let Some(import) = parser.parse()? { + (parser.parse()?, GlobalKind::Import(import)) + } else { + (parser.parse()?, GlobalKind::Inline(parser.parse()?)) + }; + Ok(Global { + span, + id, + name, + exports, + ty, + kind, + }) + } +} diff --git a/crates/wastlhw/src/core/import.rs b/crates/wastlhw/src/core/import.rs new file mode 100644 index 000000000..e44057f72 --- /dev/null +++ b/crates/wastlhw/src/core/import.rs @@ -0,0 +1,158 @@ +use crate::core::*; +use crate::kw; +use crate::parser::{Cursor, Parse, Parser, Peek, Result}; +use crate::token::{Id, NameAnnotation, Span}; + +/// An `import` statement and entry in a WebAssembly module. +#[derive(Debug, Clone)] +pub struct Import<'a> { + /// Where this `import` was defined + pub span: Span, + /// The module that this statement is importing from + pub module: &'a str, + /// The name of the field in the module this statement imports from. + pub field: &'a str, + /// The item that's being imported. + pub item: ItemSig<'a>, +} + +impl<'a> Parse<'a> for Import<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let module = parser.parse()?; + let field = parser.parse()?; + let item = parser.parens(|p| p.parse())?; + Ok(Import { + span, + module, + field, + item, + }) + } +} + +#[derive(Debug, Clone)] +#[allow(missing_docs)] +pub struct ItemSig<'a> { + /// Where this item is defined in the source. + pub span: Span, + /// An optional identifier used during name resolution to refer to this item + /// from the rest of the module. + pub id: Option>, + /// An optional name which, for functions, will be stored in the + /// custom `name` section. + pub name: Option>, + /// What kind of item this is. + pub kind: ItemKind<'a>, +} + +#[derive(Debug, Clone)] +#[allow(missing_docs)] +pub enum ItemKind<'a> { + Func(TypeUse<'a, FunctionType<'a>>), + Table(TableType<'a>), + Memory(MemoryType), + Global(GlobalType<'a>), + Tag(TagType<'a>), +} + +impl<'a> Parse<'a> for ItemSig<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + let span = parser.parse::()?.0; + Ok(ItemSig { + span, + id: parser.parse()?, + name: parser.parse()?, + kind: ItemKind::Func(parser.parse()?), + }) + } else if l.peek::() { + let span = parser.parse::()?.0; + Ok(ItemSig { + span, + id: parser.parse()?, + name: None, + kind: ItemKind::Table(parser.parse()?), + }) + } else if l.peek::() { + let span = parser.parse::()?.0; + Ok(ItemSig { + span, + id: parser.parse()?, + name: None, + kind: ItemKind::Memory(parser.parse()?), + }) + } else if l.peek::() { + let span = parser.parse::()?.0; + Ok(ItemSig { + span, + id: parser.parse()?, + name: None, + kind: ItemKind::Global(parser.parse()?), + }) + } else if l.peek::() { + let span = parser.parse::()?.0; + Ok(ItemSig { + span, + id: parser.parse()?, + name: None, + kind: ItemKind::Tag(parser.parse()?), + }) + } else { + Err(l.error()) + } + } +} + +/// A listing of a inline `(import "foo")` statement. +/// +/// Note that when parsing this type it is somewhat unconventional that it +/// parses its own surrounding parentheses. This is typically an optional type, +/// so it's so far been a bit nicer to have the optionality handled through +/// `Peek` rather than `Option`. +#[derive(Debug, Copy, Clone)] +#[allow(missing_docs)] +pub struct InlineImport<'a> { + pub module: &'a str, + pub field: &'a str, +} + +impl<'a> Parse<'a> for InlineImport<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parens(|p| { + p.parse::()?; + Ok(InlineImport { + module: p.parse()?, + field: p.parse()?, + }) + }) + } +} + +impl Peek for InlineImport<'_> { + fn peek(cursor: Cursor<'_>) -> bool { + let cursor = match cursor.lparen() { + Some(cursor) => cursor, + None => return false, + }; + let cursor = match cursor.keyword() { + Some(("import", cursor)) => cursor, + _ => return false, + }; + let cursor = match cursor.string() { + Some((_, cursor)) => cursor, + None => return false, + }; + let cursor = match cursor.string() { + Some((_, cursor)) => cursor, + None => return false, + }; + + cursor.rparen().is_some() + } + + fn display() -> &'static str { + "inline import" + } +} diff --git a/crates/wastlhw/src/core/memory.rs b/crates/wastlhw/src/core/memory.rs new file mode 100644 index 000000000..ed845e055 --- /dev/null +++ b/crates/wastlhw/src/core/memory.rs @@ -0,0 +1,279 @@ +use crate::core::*; +use crate::kw; +use crate::parser::{Lookahead1, Parse, Parser, Peek, Result}; +use crate::token::*; + +/// A defined WebAssembly memory instance inside of a module. +#[derive(Debug)] +pub struct Memory<'a> { + /// Where this `memory` was defined + pub span: Span, + /// An optional name to refer to this memory by. + pub id: Option>, + /// An optional name for this function stored in the custom `name` section. + pub name: Option>, + /// If present, inline export annotations which indicate names this + /// definition should be exported under. + pub exports: InlineExport<'a>, + /// How this memory is defined in the module. + pub kind: MemoryKind<'a>, +} + +/// Different syntactical ways a memory can be defined in a module. +#[derive(Debug)] +pub enum MemoryKind<'a> { + /// This memory is actually an inlined import definition. + #[allow(missing_docs)] + Import { + import: InlineImport<'a>, + ty: MemoryType, + }, + + /// A typical memory definition which simply says the limits of the memory + Normal(MemoryType), + + /// The data of this memory, starting from 0, explicitly listed + Inline { + /// Whether or not this will be creating a 32-bit memory + is_32: bool, + /// The inline data specified for this memory + data: Vec>, + }, +} + +impl<'a> Parse<'a> for Memory<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let id = parser.parse()?; + let name = parser.parse()?; + let exports = parser.parse()?; + + // Afterwards figure out which style this is, either: + // + // * `(import "a" "b") limits` + // * `(data ...)` + // * `limits` + let mut l = parser.lookahead1(); + let kind = if let Some(import) = parser.parse()? { + MemoryKind::Import { + import, + ty: parser.parse()?, + } + } else if l.peek::() || parser.peek2::() { + let is_32 = if parser.parse::>()?.is_some() { + true + } else { + parser.parse::>()?.is_none() + }; + let data = parser.parens(|parser| { + parser.parse::()?; + let mut data = Vec::new(); + while !parser.is_empty() { + data.push(parser.parse()?); + } + Ok(data) + })?; + MemoryKind::Inline { data, is_32 } + } else if l.peek::() || l.peek::() || l.peek::() { + MemoryKind::Normal(parser.parse()?) + } else { + return Err(l.error()); + }; + Ok(Memory { + span, + id, + name, + exports, + kind, + }) + } +} + +/// A `data` directive in a WebAssembly module. +#[derive(Debug)] +pub struct Data<'a> { + /// Where this `data` was defined + pub span: Span, + + /// The optional name of this data segment + pub id: Option>, + + /// An optional name for this data stored in the custom `name` section. + pub name: Option>, + + /// Whether this data segment is passive or active + pub kind: DataKind<'a>, + + /// Bytes for this `Data` segment, viewed as the concatenation of all the + /// contained slices. + pub data: Vec>, +} + +/// Different kinds of data segments, either passive or active. +#[derive(Debug)] +pub enum DataKind<'a> { + /// A passive data segment which isn't associated with a memory and is + /// referenced from various instructions. + Passive, + + /// An active data segment which is associated and loaded into a particular + /// memory on module instantiation. + Active { + /// The memory that this `Data` will be associated with. + memory: Index<'a>, + + /// Initial offset to load this data segment at + offset: Expression<'a>, + }, +} + +impl<'a> Parse<'a> for Data<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let id = parser.parse()?; + let name = parser.parse()?; + + let kind = if parser.peek::<&[u8]>() { + DataKind::Passive + + // ... and otherwise we must be attached to a particular memory as well + // as having an initialization offset. + } else { + let memory = if parser.peek::() { + // FIXME: this is only here to accomodate + // proposals/threads/imports.wast at this current moment in + // time, this probably should get removed when the threads + // proposal is rebased on the current spec. + Index::Num(parser.parse()?, span) + } else if parser.peek2::() { + parser.parens(|p| { + p.parse::()?; + p.parse() + })? + } else { + Index::Num(0, span) + }; + let offset = parser.parens(|parser| { + if parser.peek::() { + parser.parse::()?; + parser.parse() + } else { + // This is all that the spec allows, which is that if + // `offset` isn't present then this is "sugar" for a + // single-instruction expression. + let insn = parser.parse()?; + if parser.is_empty() { + return Ok(Expression { + instrs: [insn].into(), + }); + } + + // This is support for what is currently invalid syntax + // according to the strict specification but is otherwise + // present in the spec test suite: + // + // (data (i32.add (i32.const 0) (i32.const 0))) + // + // Technically the spec says this should be: + // + // (data (offset ...)) + // + // but alas + let expr: Expression = parser.parse()?; + let mut instrs = Vec::from(expr.instrs); + instrs.push(insn); + Ok(Expression { + instrs: instrs.into(), + }) + } + })?; + DataKind::Active { memory, offset } + }; + + let mut data = Vec::new(); + while !parser.is_empty() { + data.push(parser.parse()?); + } + Ok(Data { + span, + id, + name, + kind, + data, + }) + } +} + +/// Differnet ways the value of a data segment can be defined. +#[derive(Debug)] +#[allow(missing_docs)] +pub enum DataVal<'a> { + String(&'a [u8]), + Integral(Vec), +} + +impl DataVal<'_> { + /// Returns the length, in bytes, of the memory used to represent this data + /// value. + pub fn len(&self) -> usize { + match self { + DataVal::String(s) => s.len(), + DataVal::Integral(s) => s.len(), + } + } + + /// Pushes the value of this data value onto the provided list of bytes. + pub fn push_onto(&self, dst: &mut Vec) { + match self { + DataVal::String(s) => dst.extend_from_slice(s), + DataVal::Integral(s) => dst.extend_from_slice(s), + } + } +} + +impl<'a> Parse<'a> for DataVal<'a> { + fn parse(parser: Parser<'a>) -> Result { + if !parser.peek::() { + return Ok(DataVal::String(parser.parse()?)); + } + + return parser.parens(|p| { + let mut result = Vec::new(); + let mut lookahead = p.lookahead1(); + let l = &mut lookahead; + let r = &mut result; + if consume::(p, l, r, |u, v| v.push(u as u8))? + || consume::(p, l, r, |u, v| v.extend(&u.to_le_bytes()))? + || consume::(p, l, r, |u, v| v.extend(&u.to_le_bytes()))? + || consume::(p, l, r, |u, v| v.extend(&u.to_le_bytes()))? + || consume::(p, l, r, |u, v| v.extend(&u.bits.to_le_bytes()))? + || consume::(p, l, r, |u, v| v.extend(&u.bits.to_le_bytes()))? + || consume::(p, l, r, |u, v| v.extend(&u.to_le_bytes()))? + { + Ok(DataVal::Integral(result)) + } else { + Err(lookahead.error()) + } + }); + + fn consume<'a, T: Peek + Parse<'a>, U: Parse<'a>, F>( + parser: Parser<'a>, + lookahead: &mut Lookahead1<'a>, + dst: &mut Vec, + push: F, + ) -> Result + where + F: Fn(U, &mut Vec), + { + if !lookahead.peek::() { + return Ok(false); + } + parser.parse::()?; + while !parser.is_empty() { + let val = parser.parse::()?; + push(val, dst); + } + Ok(true) + } + } +} diff --git a/crates/wastlhw/src/core/module.rs b/crates/wastlhw/src/core/module.rs new file mode 100644 index 000000000..b6e3ca0ad --- /dev/null +++ b/crates/wastlhw/src/core/module.rs @@ -0,0 +1,210 @@ +use crate::core::*; +use crate::parser::{Parse, Parser, Result}; +use crate::token::{Id, Index, NameAnnotation, Span}; +use crate::{annotation, kw}; + +pub use crate::core::resolve::Names; + +/// A parsed WebAssembly core module. +#[derive(Debug)] +pub struct Module<'a> { + /// Where this `module` was defined + pub span: Span, + /// An optional identifier this module is known by + pub id: Option>, + /// An optional `@name` annotation for this module + pub name: Option>, + /// What kind of module this was parsed as. + pub kind: ModuleKind<'a>, +} + +/// The different kinds of ways to define a module. +#[derive(Debug)] +pub enum ModuleKind<'a> { + /// A module defined in the textual s-expression format. + Text(Vec>), + /// A module that had its raw binary bytes defined via the `binary` + /// directive. + Binary(Vec<&'a [u8]>), +} + +impl<'a> Module<'a> { + /// Performs a name resolution pass on this [`Module`], resolving all + /// symbolic names to indices. + /// + /// The WAT format contains a number of shorthands to make it easier to + /// write, such as inline exports, inline imports, inline type definitions, + /// etc. Additionally it allows using symbolic names such as `$foo` instead + /// of using indices. This module will postprocess an AST to remove all of + /// this syntactic sugar, preparing the AST for binary emission. This is + /// where expansion and name resolution happens. + /// + /// This function will mutate the AST of this [`Module`] and replace all + /// [`Index`](crate::token::Index) arguments with `Index::Num`. This will + /// also expand inline exports/imports listed on fields and handle various + /// other shorthands of the text format. + /// + /// If successful the AST was modified to be ready for binary encoding. A + /// [`Names`] structure is also returned so if you'd like to do your own + /// name lookups on the result you can do so as well. + /// + /// # Errors + /// + /// If an error happens during resolution, such a name resolution error or + /// items are found in the wrong order, then an error is returned. + pub fn resolve(&mut self) -> std::result::Result, crate::Error> { + let names = match &mut self.kind { + ModuleKind::Text(fields) => crate::core::resolve::resolve(fields)?, + ModuleKind::Binary(_blobs) => Default::default(), + }; + Ok(names) + } + + /// Encodes this [`Module`] to its binary form. + /// + /// This function will take the textual representation in [`Module`] and + /// perform all steps necessary to convert it to a binary WebAssembly + /// module, suitable for writing to a `*.wasm` file. This function may + /// internally modify the [`Module`], for example: + /// + /// * Name resolution is performed to ensure that `Index::Id` isn't present + /// anywhere in the AST. + /// + /// * Inline shorthands such as imports/exports/types are all expanded to be + /// dedicated fields of the module. + /// + /// * Module fields may be shuffled around to preserve index ordering from + /// expansions. + /// + /// After all of this expansion has happened the module will be converted to + /// its binary form and returned as a `Vec`. This is then suitable to + /// hand off to other wasm runtimes and such. + /// + /// # Errors + /// + /// This function can return an error for name resolution errors and other + /// expansion-related errors. + pub fn encode(&mut self) -> std::result::Result, crate::Error> { + self.resolve()?; + Ok(match &self.kind { + ModuleKind::Text(fields) => crate::core::binary::encode(&self.id, &self.name, fields), + ModuleKind::Binary(blobs) => blobs.iter().flat_map(|b| b.iter().cloned()).collect(), + }) + } + + pub(crate) fn validate(&self, parser: Parser<'_>) -> Result<()> { + let mut starts = 0; + if let ModuleKind::Text(fields) = &self.kind { + for item in fields.iter() { + if let ModuleField::Start(_) = item { + starts += 1; + } + } + } + if starts > 1 { + return Err(parser.error("multiple start sections found")); + } + Ok(()) + } +} + +impl<'a> Parse<'a> for Module<'a> { + fn parse(parser: Parser<'a>) -> Result { + let _r = parser.register_annotation("custom"); + let span = parser.parse::()?.0; + let id = parser.parse()?; + let name = parser.parse()?; + + let kind = if parser.peek::() { + parser.parse::()?; + let mut data = Vec::new(); + while !parser.is_empty() { + data.push(parser.parse()?); + } + ModuleKind::Binary(data) + } else { + ModuleKind::Text(ModuleField::parse_remaining(parser)?) + }; + Ok(Module { + span, + id, + name, + kind, + }) + } +} + +/// A listing of all possible fields that can make up a WebAssembly module. +#[allow(missing_docs)] +#[derive(Debug)] +pub enum ModuleField<'a> { + Type(Type<'a>), + Rec(Rec<'a>), + Import(Import<'a>), + Func(Func<'a>), + Table(Table<'a>), + Memory(Memory<'a>), + Global(Global<'a>), + Export(Export<'a>), + Start(Index<'a>), + Elem(Elem<'a>), + Data(Data<'a>), + Tag(Tag<'a>), + Custom(Custom<'a>), +} + +impl<'a> ModuleField<'a> { + pub(crate) fn parse_remaining(parser: Parser<'a>) -> Result> { + let mut fields = Vec::new(); + while !parser.is_empty() { + fields.push(parser.parens(ModuleField::parse)?); + } + Ok(fields) + } +} + +impl<'a> Parse<'a> for ModuleField<'a> { + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::>() { + return Ok(ModuleField::Type(parser.parse()?)); + } + if parser.peek::() { + return Ok(ModuleField::Rec(parser.parse()?)); + } + if parser.peek::() { + return Ok(ModuleField::Import(parser.parse()?)); + } + if parser.peek::() { + return Ok(ModuleField::Func(parser.parse()?)); + } + if parser.peek::() { + return Ok(ModuleField::Table(parser.parse()?)); + } + if parser.peek::() { + return Ok(ModuleField::Memory(parser.parse()?)); + } + if parser.peek::() { + return Ok(ModuleField::Global(parser.parse()?)); + } + if parser.peek::() { + return Ok(ModuleField::Export(parser.parse()?)); + } + if parser.peek::() { + parser.parse::()?; + return Ok(ModuleField::Start(parser.parse()?)); + } + if parser.peek::() { + return Ok(ModuleField::Elem(parser.parse()?)); + } + if parser.peek::() { + return Ok(ModuleField::Data(parser.parse()?)); + } + if parser.peek::() { + return Ok(ModuleField::Tag(parser.parse()?)); + } + if parser.peek::() { + return Ok(ModuleField::Custom(parser.parse()?)); + } + Err(parser.error("expected valid module field")) + } +} diff --git a/crates/wastlhw/src/core/resolve/deinline_import_export.rs b/crates/wastlhw/src/core/resolve/deinline_import_export.rs new file mode 100644 index 000000000..db8870681 --- /dev/null +++ b/crates/wastlhw/src/core/resolve/deinline_import_export.rs @@ -0,0 +1,228 @@ +use crate::core::*; +use crate::gensym; +use crate::token::{Id, Index, Span}; +use std::mem; + +pub fn run(fields: &mut Vec) { + for mut item in mem::take(fields) { + match &mut item { + ModuleField::Func(f) => { + for name in f.exports.names.drain(..) { + fields.push(export(f.span, name, ExportKind::Func, &mut f.id)); + } + match f.kind { + FuncKind::Import(import) => { + item = ModuleField::Import(Import { + span: f.span, + module: import.module, + field: import.field, + item: ItemSig { + span: f.span, + id: f.id, + name: f.name, + kind: ItemKind::Func(f.ty.clone()), + }, + }); + } + FuncKind::Inline { .. } => {} + } + } + + ModuleField::Memory(m) => { + for name in m.exports.names.drain(..) { + fields.push(export(m.span, name, ExportKind::Memory, &mut m.id)); + } + match m.kind { + MemoryKind::Import { import, ty } => { + item = ModuleField::Import(Import { + span: m.span, + module: import.module, + field: import.field, + item: ItemSig { + span: m.span, + id: m.id, + name: None, + kind: ItemKind::Memory(ty), + }, + }); + } + // If data is defined inline insert an explicit `data` module + // field here instead, switching this to a `Normal` memory. + MemoryKind::Inline { is_32, ref data } => { + let len = data.iter().map(|l| l.len()).sum::() as u32; + let pages = (len + page_size() - 1) / page_size(); + let kind = MemoryKind::Normal(if is_32 { + MemoryType::B32 { + limits: Limits { + min: pages, + max: Some(pages), + }, + shared: false, + } + } else { + MemoryType::B64 { + limits: Limits64 { + min: u64::from(pages), + max: Some(u64::from(pages)), + }, + shared: false, + } + }); + let data = match mem::replace(&mut m.kind, kind) { + MemoryKind::Inline { data, .. } => data, + _ => unreachable!(), + }; + let id = gensym::fill(m.span, &mut m.id); + fields.push(ModuleField::Data(Data { + span: m.span, + id: None, + name: None, + kind: DataKind::Active { + memory: Index::Id(id), + offset: Expression { + instrs: Box::new([if is_32 { + Instruction::I32Const(0) + } else { + Instruction::I64Const(0) + }]), + }, + }, + data, + })); + } + + MemoryKind::Normal(_) => {} + } + } + + ModuleField::Table(t) => { + for name in t.exports.names.drain(..) { + fields.push(export(t.span, name, ExportKind::Table, &mut t.id)); + } + match &mut t.kind { + TableKind::Import { import, ty } => { + item = ModuleField::Import(Import { + span: t.span, + module: import.module, + field: import.field, + item: ItemSig { + span: t.span, + id: t.id, + name: None, + kind: ItemKind::Table(*ty), + }, + }); + } + // If data is defined inline insert an explicit `data` module + // field here instead, switching this to a `Normal` memory. + TableKind::Inline { payload, elem } => { + let len = match payload { + ElemPayload::Indices(v) => v.len(), + ElemPayload::Exprs { exprs, .. } => exprs.len(), + }; + let kind = TableKind::Normal(TableType { + limits: Limits { + min: len as u32, + max: Some(len as u32), + }, + elem: *elem, + }); + let payload = match mem::replace(&mut t.kind, kind) { + TableKind::Inline { payload, .. } => payload, + _ => unreachable!(), + }; + let id = gensym::fill(t.span, &mut t.id); + fields.push(ModuleField::Elem(Elem { + span: t.span, + id: None, + name: None, + kind: ElemKind::Active { + table: Index::Id(id), + offset: Expression { + instrs: Box::new([Instruction::I32Const(0)]), + }, + }, + payload, + })); + } + + TableKind::Normal(_) => {} + } + } + + ModuleField::Global(g) => { + for name in g.exports.names.drain(..) { + fields.push(export(g.span, name, ExportKind::Global, &mut g.id)); + } + match g.kind { + GlobalKind::Import(import) => { + item = ModuleField::Import(Import { + span: g.span, + module: import.module, + field: import.field, + item: ItemSig { + span: g.span, + id: g.id, + name: None, + kind: ItemKind::Global(g.ty), + }, + }); + } + GlobalKind::Inline { .. } => {} + } + } + + ModuleField::Tag(e) => { + for name in e.exports.names.drain(..) { + fields.push(export(e.span, name, ExportKind::Tag, &mut e.id)); + } + match e.kind { + TagKind::Import(import) => { + item = ModuleField::Import(Import { + span: e.span, + module: import.module, + field: import.field, + item: ItemSig { + span: e.span, + id: e.id, + name: None, + kind: ItemKind::Tag(e.ty.clone()), + }, + }); + } + TagKind::Inline { .. } => {} + } + } + + ModuleField::Import(_) + | ModuleField::Type(_) + | ModuleField::Rec(_) + | ModuleField::Export(_) + | ModuleField::Start(_) + | ModuleField::Elem(_) + | ModuleField::Data(_) + | ModuleField::Custom(_) => {} + } + + fields.push(item); + } + + fn page_size() -> u32 { + 1 << 16 + } +} + +fn export<'a>( + span: Span, + name: &'a str, + kind: ExportKind, + id: &mut Option>, +) -> ModuleField<'a> { + let id = gensym::fill(span, id); + ModuleField::Export(Export { + span, + name, + kind, + item: Index::Id(id), + }) +} diff --git a/crates/wastlhw/src/core/resolve/mod.rs b/crates/wastlhw/src/core/resolve/mod.rs new file mode 100644 index 000000000..7b3ba2b1e --- /dev/null +++ b/crates/wastlhw/src/core/resolve/mod.rs @@ -0,0 +1,109 @@ +use crate::core::*; +use crate::token::Index; +use crate::{gensym, Error}; + +mod deinline_import_export; +mod names; +pub(crate) mod types; + +#[derive(PartialEq, Eq, Hash, Copy, Clone, Debug)] +pub enum Ns { + Func, + Table, + Global, + Memory, + Tag, + Type, +} + +pub fn resolve<'a>(fields: &mut Vec>) -> Result, Error> { + // Ensure that each resolution of a module is deterministic in the names + // that it generates by resetting our thread-local symbol generator. + gensym::reset(); + + // First up, de-inline import/export annotations. + // + // This ensures we only have to deal with inline definitions and to + // calculate exports we only have to look for a particular kind of module + // field. + deinline_import_export::run(fields); + + // With a canonical form of imports make sure that imports are all listed + // first. + let mut last = None; + for field in fields.iter() { + match field { + ModuleField::Import(i) => { + if let Some(name) = last { + return Err(Error::new(i.span, format!("import after {}", name))); + } + } + ModuleField::Memory(_) => last = Some("memory"), + ModuleField::Func(_) => last = Some("function"), + ModuleField::Table(_) => last = Some("table"), + ModuleField::Global(_) => last = Some("global"), + _ => continue, + } + } + + // Expand all `TypeUse` annotations so all necessary `type` nodes are + // present in the AST. + types::expand(fields); + + // Perform name resolution over all `Index` items to resolve them all to + // indices instead of symbolic names. + let resolver = names::resolve(fields)?; + Ok(Names { resolver }) +} + +/// Representation of the results of name resolution for a module. +/// +/// This structure is returned from the +/// [`Module::resolve`](crate::core::Module::resolve) function and can be used +/// to resolve your own name arguments if you have any. +#[derive(Default)] +pub struct Names<'a> { + resolver: names::Resolver<'a>, +} + +impl<'a> Names<'a> { + /// Resolves `idx` within the function namespace. + /// + /// If `idx` is a `Num`, it is ignored, but if it's an `Id` then it will be + /// looked up in the function namespace and converted to a `Num`. If the + /// `Id` is not defined then an error will be returned. + pub fn resolve_func(&self, idx: &mut Index<'a>) -> Result<(), Error> { + self.resolver.resolve(idx, Ns::Func)?; + Ok(()) + } + + /// Resolves `idx` within the memory namespace. + /// + /// If `idx` is a `Num`, it is ignored, but if it's an `Id` then it will be + /// looked up in the memory namespace and converted to a `Num`. If the + /// `Id` is not defined then an error will be returned. + pub fn resolve_memory(&self, idx: &mut Index<'a>) -> Result<(), Error> { + self.resolver.resolve(idx, Ns::Memory)?; + Ok(()) + } + + /// Resolves `idx` within the table namespace. + /// + /// If `idx` is a `Num`, it is ignored, but if it's an `Id` then it will be + /// looked up in the table namespace and converted to a `Num`. If the + /// `Id` is not defined then an error will be returned. + pub fn resolve_table(&self, idx: &mut Index<'a>) -> Result<(), Error> { + self.resolver.resolve(idx, Ns::Table)?; + Ok(()) + } + + /// Resolves `idx` within the global namespace. + /// + /// If `idx` is a `Num`, it is ignored, but if it's an `Id` then it will be + /// looked up in the global namespace and converted to a `Num`. If the + /// `Id` is not defined then an error will be returned. + pub fn resolve_global(&self, idx: &mut Index<'a>) -> Result<(), Error> { + self.resolver.resolve(idx, Ns::Global)?; + Ok(()) + } +} diff --git a/crates/wastlhw/src/core/resolve/names.rs b/crates/wastlhw/src/core/resolve/names.rs new file mode 100644 index 000000000..e65b72a77 --- /dev/null +++ b/crates/wastlhw/src/core/resolve/names.rs @@ -0,0 +1,746 @@ +use crate::core::resolve::Ns; +use crate::core::*; +use crate::names::{resolve_error, Namespace}; +use crate::token::{Id, Index}; +use crate::Error; + +pub fn resolve<'a>(fields: &mut Vec>) -> Result, Error> { + let mut resolver = Resolver::default(); + resolver.process(fields)?; + Ok(resolver) +} + +/// Context structure used to perform name resolution. +#[derive(Default)] +pub struct Resolver<'a> { + // Namespaces within each module. Note that each namespace carries with it + // information about the signature of the item in that namespace. The + // signature is later used to synthesize the type of a module and inject + // type annotations if necessary. + funcs: Namespace<'a>, + globals: Namespace<'a>, + tables: Namespace<'a>, + memories: Namespace<'a>, + types: Namespace<'a>, + tags: Namespace<'a>, + datas: Namespace<'a>, + elems: Namespace<'a>, + fields: Namespace<'a>, + type_info: Vec>, +} + +impl<'a> Resolver<'a> { + fn process(&mut self, fields: &mut Vec>) -> Result<(), Error> { + // Number everything in the module, recording what names correspond to + // what indices. + for field in fields.iter_mut() { + self.register(field)?; + } + + // Then we can replace all our `Index::Id` instances with `Index::Num` + // in the AST. Note that this also recurses into nested modules. + for field in fields.iter_mut() { + self.resolve_field(field)?; + } + Ok(()) + } + + fn register_type(&mut self, ty: &Type<'a>) -> Result<(), Error> { + match &ty.def { + // For GC structure types we need to be sure to populate the + // field namespace here as well. + // + // The field namespace is global, but the resolved indices + // are relative to the struct they are defined in + TypeDef::Struct(r#struct) => { + for (i, field) in r#struct.fields.iter().enumerate() { + if let Some(id) = field.id { + self.fields.register_specific(id, i as u32, "field")?; + } + } + } + + TypeDef::Array(_) | TypeDef::Func(_) => {} + } + + // Record function signatures as we see them to so we can + // generate errors for mismatches in references such as + // `call_indirect`. + match &ty.def { + TypeDef::Func(f) => { + let params = f.params.iter().map(|p| p.2).collect(); + let results = f.results.clone(); + self.type_info.push(TypeInfo::Func { params, results }); + } + _ => self.type_info.push(TypeInfo::Other), + } + + self.types.register(ty.id, "type")?; + Ok(()) + } + + fn register(&mut self, item: &ModuleField<'a>) -> Result<(), Error> { + match item { + ModuleField::Import(i) => match &i.item.kind { + ItemKind::Func(_) => self.funcs.register(i.item.id, "func")?, + ItemKind::Memory(_) => self.memories.register(i.item.id, "memory")?, + ItemKind::Table(_) => self.tables.register(i.item.id, "table")?, + ItemKind::Global(_) => self.globals.register(i.item.id, "global")?, + ItemKind::Tag(_) => self.tags.register(i.item.id, "tag")?, + }, + ModuleField::Global(i) => self.globals.register(i.id, "global")?, + ModuleField::Memory(i) => self.memories.register(i.id, "memory")?, + ModuleField::Func(i) => self.funcs.register(i.id, "func")?, + ModuleField::Table(i) => self.tables.register(i.id, "table")?, + + ModuleField::Type(i) => { + return self.register_type(i); + } + ModuleField::Rec(i) => { + for ty in &i.types { + self.register_type(ty)?; + } + return Ok(()); + } + ModuleField::Elem(e) => self.elems.register(e.id, "elem")?, + ModuleField::Data(d) => self.datas.register(d.id, "data")?, + ModuleField::Tag(t) => self.tags.register(t.id, "tag")?, + + // These fields don't define any items in any index space. + ModuleField::Export(_) | ModuleField::Start(_) | ModuleField::Custom(_) => { + return Ok(()) + } + }; + + Ok(()) + } + + fn resolve_type(&self, ty: &mut Type<'a>) -> Result<(), Error> { + match &mut ty.def { + TypeDef::Func(func) => func.resolve(self)?, + TypeDef::Struct(struct_) => { + for field in &mut struct_.fields { + self.resolve_storagetype(&mut field.ty)?; + } + } + TypeDef::Array(array) => self.resolve_storagetype(&mut array.ty)?, + } + if let Some(parent) = &mut ty.parent { + self.resolve(parent, Ns::Type)?; + } + Ok(()) + } + + fn resolve_field(&self, field: &mut ModuleField<'a>) -> Result<(), Error> { + match field { + ModuleField::Import(i) => { + self.resolve_item_sig(&mut i.item)?; + Ok(()) + } + + ModuleField::Type(ty) => self.resolve_type(ty), + ModuleField::Rec(rec) => { + for ty in &mut rec.types { + self.resolve_type(ty)?; + } + Ok(()) + } + + ModuleField::Func(f) => { + let (idx, inline) = self.resolve_type_use(&mut f.ty)?; + let n = match idx { + Index::Num(n, _) => *n, + Index::Id(_) => panic!("expected `Num`"), + }; + if let FuncKind::Inline { locals, expression } = &mut f.kind { + // Resolve (ref T) in locals + for local in locals.iter_mut() { + self.resolve_valtype(&mut local.ty)?; + } + + // Build a scope with a local namespace for the function + // body + let mut scope = Namespace::default(); + + // Parameters come first in the scope... + if let Some(inline) = &inline { + for (id, _, _) in inline.params.iter() { + scope.register(*id, "local")?; + } + } else if let Some(TypeInfo::Func { params, .. }) = + self.type_info.get(n as usize) + { + for _ in 0..params.len() { + scope.register(None, "local")?; + } + } + + // .. followed by locals themselves + for local in locals { + scope.register(local.id, "local")?; + } + + // Initialize the expression resolver with this scope + let mut resolver = ExprResolver::new(self, scope); + + // and then we can resolve the expression! + resolver.resolve(expression)?; + + // specifically save the original `sig`, if it was present, + // because that's what we're using for local names. + f.ty.inline = inline; + } + Ok(()) + } + + ModuleField::Elem(e) => { + match &mut e.kind { + ElemKind::Active { table, offset } => { + self.resolve(table, Ns::Table)?; + self.resolve_expr(offset)?; + } + ElemKind::Passive { .. } | ElemKind::Declared { .. } => {} + } + match &mut e.payload { + ElemPayload::Indices(elems) => { + for idx in elems { + self.resolve(idx, Ns::Func)?; + } + } + ElemPayload::Exprs { exprs, ty } => { + for expr in exprs { + self.resolve_expr(expr)?; + } + self.resolve_heaptype(&mut ty.heap)?; + } + } + Ok(()) + } + + ModuleField::Data(d) => { + if let DataKind::Active { memory, offset } = &mut d.kind { + self.resolve(memory, Ns::Memory)?; + self.resolve_expr(offset)?; + } + Ok(()) + } + + ModuleField::Start(i) => { + self.resolve(i, Ns::Func)?; + Ok(()) + } + + ModuleField::Export(e) => { + self.resolve( + &mut e.item, + match e.kind { + ExportKind::Func => Ns::Func, + ExportKind::Table => Ns::Table, + ExportKind::Memory => Ns::Memory, + ExportKind::Global => Ns::Global, + ExportKind::Tag => Ns::Tag, + }, + )?; + Ok(()) + } + + ModuleField::Global(g) => { + self.resolve_valtype(&mut g.ty.ty)?; + if let GlobalKind::Inline(expr) = &mut g.kind { + self.resolve_expr(expr)?; + } + Ok(()) + } + + ModuleField::Tag(t) => { + match &mut t.ty { + TagType::Exception(ty) => { + self.resolve_type_use(ty)?; + } + } + Ok(()) + } + + ModuleField::Table(t) => { + if let TableKind::Normal(t) = &mut t.kind { + self.resolve_heaptype(&mut t.elem.heap)?; + } + Ok(()) + } + + ModuleField::Memory(_) | ModuleField::Custom(_) => Ok(()), + } + } + + fn resolve_valtype(&self, ty: &mut ValType<'a>) -> Result<(), Error> { + match ty { + ValType::Ref(ty) => self.resolve_heaptype(&mut ty.heap)?, + _ => {} + } + Ok(()) + } + + fn resolve_heaptype(&self, ty: &mut HeapType<'a>) -> Result<(), Error> { + match ty { + HeapType::Index(i) => { + self.resolve(i, Ns::Type)?; + } + _ => {} + } + Ok(()) + } + + fn resolve_storagetype(&self, ty: &mut StorageType<'a>) -> Result<(), Error> { + match ty { + StorageType::Val(ty) => self.resolve_valtype(ty)?, + _ => {} + } + Ok(()) + } + + fn resolve_item_sig(&self, item: &mut ItemSig<'a>) -> Result<(), Error> { + match &mut item.kind { + ItemKind::Func(t) | ItemKind::Tag(TagType::Exception(t)) => { + self.resolve_type_use(t)?; + } + ItemKind::Global(t) => self.resolve_valtype(&mut t.ty)?, + ItemKind::Table(t) => { + self.resolve_heaptype(&mut t.elem.heap)?; + } + ItemKind::Memory(_) => {} + } + Ok(()) + } + + fn resolve_type_use<'b, T>( + &self, + ty: &'b mut TypeUse<'a, T>, + ) -> Result<(&'b Index<'a>, Option), Error> + where + T: TypeReference<'a>, + { + let idx = ty.index.as_mut().unwrap(); + self.resolve(idx, Ns::Type)?; + + // If the type was listed inline *and* it was specified via a type index + // we need to assert they're the same. + // + // Note that we resolve the type first to transform all names to + // indices to ensure that all the indices line up. + if let Some(inline) = &mut ty.inline { + inline.resolve(self)?; + inline.check_matches(idx, self)?; + } + + Ok((idx, ty.inline.take())) + } + + fn resolve_expr(&self, expr: &mut Expression<'a>) -> Result<(), Error> { + ExprResolver::new(self, Namespace::default()).resolve(expr) + } + + pub fn resolve(&self, idx: &mut Index<'a>, ns: Ns) -> Result { + match ns { + Ns::Func => self.funcs.resolve(idx, "func"), + Ns::Table => self.tables.resolve(idx, "table"), + Ns::Global => self.globals.resolve(idx, "global"), + Ns::Memory => self.memories.resolve(idx, "memory"), + Ns::Tag => self.tags.resolve(idx, "tag"), + Ns::Type => self.types.resolve(idx, "type"), + } + } +} + +#[derive(Debug, Clone)] +struct ExprBlock<'a> { + // The label of the block + label: Option>, + // Whether this block pushed a new scope for resolving locals + pushed_scope: bool, +} + +struct ExprResolver<'a, 'b> { + resolver: &'b Resolver<'a>, + // Scopes tracks the local namespace and dynamically grows as we enter/exit + // `let` blocks + scopes: Vec>, + blocks: Vec>, +} + +impl<'a, 'b> ExprResolver<'a, 'b> { + fn new(resolver: &'b Resolver<'a>, initial_scope: Namespace<'a>) -> ExprResolver<'a, 'b> { + ExprResolver { + resolver, + scopes: vec![initial_scope], + blocks: Vec::new(), + } + } + + fn resolve(&mut self, expr: &mut Expression<'a>) -> Result<(), Error> { + for instr in expr.instrs.iter_mut() { + self.resolve_instr(instr)?; + } + Ok(()) + } + + fn resolve_block_type(&mut self, bt: &mut BlockType<'a>) -> Result<(), Error> { + // Ok things get interesting here. First off when parsing `bt` + // *optionally* has an index and a function type listed. If + // they're both not present it's equivalent to 0 params and 0 + // results. + // + // In MVP wasm blocks can have 0 params and 0-1 results. Now + // there's also multi-value. We want to prefer MVP wasm wherever + // possible (for backcompat) so we want to list this block as + // being an "MVP" block if we can. The encoder only has + // `BlockType` to work with, so it'll be looking at `params` and + // `results` to figure out what to encode. If `params` and + // `results` fit within MVP, then it uses MVP encoding + // + // To put all that together, here we handle: + // + // * If the `index` was specified, resolve it and use it as the + // source of truth. If this turns out to be an MVP type, + // record it as such. + // * Otherwise use `params` and `results` as the source of + // truth. *If* this were a non-MVP compatible block `index` + // would be filled by by `tyexpand.rs`. + // + // tl;dr; we handle the `index` here if it's set and then fill + // out `params` and `results` if we can, otherwise no work + // happens. + if bt.ty.index.is_some() { + let (ty, _) = self.resolver.resolve_type_use(&mut bt.ty)?; + let n = match ty { + Index::Num(n, _) => *n, + Index::Id(_) => panic!("expected `Num`"), + }; + let ty = match self.resolver.type_info.get(n as usize) { + Some(TypeInfo::Func { params, results }) => (params, results), + _ => return Ok(()), + }; + if ty.0.len() == 0 && ty.1.len() <= 1 { + let mut inline = FunctionType::default(); + inline.results = ty.1.clone(); + bt.ty.inline = Some(inline); + bt.ty.index = None; + } + } + + // If the inline annotation persists to this point then resolve + // all of its inline value types. + if let Some(inline) = &mut bt.ty.inline { + inline.resolve(self.resolver)?; + } + Ok(()) + } + + fn resolve_instr(&mut self, instr: &mut Instruction<'a>) -> Result<(), Error> { + use Instruction::*; + + if let Some(m) = instr.memarg_mut() { + self.resolver.resolve(&mut m.memory, Ns::Memory)?; + } + + match instr { + MemorySize(i) | MemoryGrow(i) | MemoryFill(i) => { + self.resolver.resolve(&mut i.mem, Ns::Memory)?; + } + MemoryInit(i) => { + self.resolver.datas.resolve(&mut i.data, "data")?; + self.resolver.resolve(&mut i.mem, Ns::Memory)?; + } + MemoryCopy(i) => { + self.resolver.resolve(&mut i.src, Ns::Memory)?; + self.resolver.resolve(&mut i.dst, Ns::Memory)?; + } + DataDrop(i) => { + self.resolver.datas.resolve(i, "data")?; + } + + TableInit(i) => { + self.resolver.elems.resolve(&mut i.elem, "elem")?; + self.resolver.resolve(&mut i.table, Ns::Table)?; + } + ElemDrop(i) => { + self.resolver.elems.resolve(i, "elem")?; + } + + TableCopy(i) => { + self.resolver.resolve(&mut i.dst, Ns::Table)?; + self.resolver.resolve(&mut i.src, Ns::Table)?; + } + + TableFill(i) | TableSet(i) | TableGet(i) | TableSize(i) | TableGrow(i) => { + self.resolver.resolve(&mut i.dst, Ns::Table)?; + } + + GlobalSet(i) | GlobalGet(i) => { + self.resolver.resolve(i, Ns::Global)?; + } + + LocalSet(i) | LocalGet(i) | LocalTee(i) => { + assert!(self.scopes.len() > 0); + // Resolve a local by iterating over scopes from most recent + // to less recent. This allows locals added by `let` blocks to + // shadow less recent locals. + for (depth, scope) in self.scopes.iter().enumerate().rev() { + if let Err(e) = scope.resolve(i, "local") { + if depth == 0 { + // There are no more scopes left, report this as + // the result + return Err(e); + } + } else { + break; + } + } + // We must have taken the `break` and resolved the local + assert!(i.is_resolved()); + } + + Call(i) | RefFunc(i) | ReturnCall(i) => { + self.resolver.resolve(i, Ns::Func)?; + } + + CallIndirect(c) | ReturnCallIndirect(c) => { + self.resolver.resolve(&mut c.table, Ns::Table)?; + self.resolver.resolve_type_use(&mut c.ty)?; + } + + FuncBind(b) => { + self.resolver.resolve_type_use(&mut b.ty)?; + } + + Let(t) => { + // Resolve (ref T) in locals + for local in &mut t.locals { + self.resolver.resolve_valtype(&mut local.ty)?; + } + + // Register all locals defined in this let + let mut scope = Namespace::default(); + for local in &t.locals { + scope.register(local.id, "local")?; + } + self.scopes.push(scope); + self.blocks.push(ExprBlock { + label: t.block.label, + pushed_scope: true, + }); + + self.resolve_block_type(&mut t.block)?; + } + + Block(bt) | If(bt) | Loop(bt) | Try(bt) => { + self.blocks.push(ExprBlock { + label: bt.label, + pushed_scope: false, + }); + self.resolve_block_type(bt)?; + } + + // On `End` instructions we pop a label from the stack, and for both + // `End` and `Else` instructions if they have labels listed we + // verify that they match the label at the beginning of the block. + Else(_) | End(_) => { + let (matching_block, label) = match &instr { + Else(label) => (self.blocks.last().cloned(), label), + End(label) => (self.blocks.pop(), label), + _ => unreachable!(), + }; + let matching_block = match matching_block { + Some(l) => l, + None => return Ok(()), + }; + + // Reset the local scopes to before this block was entered + if matching_block.pushed_scope { + if let End(_) = instr { + self.scopes.pop(); + } + } + + let label = match label { + Some(l) => l, + None => return Ok(()), + }; + if Some(*label) == matching_block.label { + return Ok(()); + } + return Err(Error::new( + label.span(), + "mismatching labels between end and block".to_string(), + )); + } + + Br(i) | BrIf(i) | BrOnNull(i) | BrOnNonNull(i) => { + self.resolve_label(i)?; + } + + BrTable(i) => { + for label in i.labels.iter_mut() { + self.resolve_label(label)?; + } + self.resolve_label(&mut i.default)?; + } + + Throw(i) => { + self.resolver.resolve(i, Ns::Tag)?; + } + Rethrow(i) => { + self.resolve_label(i)?; + } + Catch(i) => { + self.resolver.resolve(i, Ns::Tag)?; + } + Delegate(i) => { + // Since a delegate starts counting one layer out from the + // current try-delegate block, we pop before we resolve labels. + self.blocks.pop(); + self.resolve_label(i)?; + } + + BrOnCast(i) | BrOnCastFail(i) => { + self.resolve_label(&mut i.label)?; + self.resolver.resolve(&mut i.r#type, Ns::Type)?; + } + + BrOnFunc(l) | BrOnData(l) | BrOnI31(l) | BrOnArray(l) | BrOnNonFunc(l) + | BrOnNonData(l) | BrOnNonI31(l) | BrOnNonArray(l) => { + self.resolve_label(l)?; + } + + Select(s) => { + if let Some(list) = &mut s.tys { + for ty in list { + self.resolver.resolve_valtype(ty)?; + } + } + } + + RefTest(i) | RefCast(i) | StructNew(i) | StructNewDefault(i) | ArrayNew(i) + | ArrayNewDefault(i) | ArrayGet(i) | ArrayGetS(i) | ArrayGetU(i) | ArraySet(i) + | ArrayLen(i) => { + self.resolver.resolve(i, Ns::Type)?; + } + + StructSet(s) | StructGet(s) | StructGetS(s) | StructGetU(s) => { + self.resolver.resolve(&mut s.r#struct, Ns::Type)?; + self.resolver.fields.resolve(&mut s.field, "field")?; + } + + ArrayNewFixed(a) => { + self.resolver.resolve(&mut a.array, Ns::Type)?; + } + ArrayNewData(a) => { + self.resolver.resolve(&mut a.array, Ns::Type)?; + self.resolver.datas.resolve(&mut a.data_idx, "data")?; + } + ArrayNewElem(a) => { + self.resolver.resolve(&mut a.array, Ns::Type)?; + self.resolver.elems.resolve(&mut a.elem_idx, "elem")?; + } + ArrayCopy(a) => { + self.resolver.resolve(&mut a.dest_array, Ns::Type)?; + self.resolver.resolve(&mut a.src_array, Ns::Type)?; + } + + RefNull(ty) => self.resolver.resolve_heaptype(ty)?, + + _ => {} + } + Ok(()) + } + + fn resolve_label(&self, label: &mut Index<'a>) -> Result<(), Error> { + let id = match label { + Index::Num(..) => return Ok(()), + Index::Id(id) => *id, + }; + let idx = self + .blocks + .iter() + .rev() + .enumerate() + .filter_map(|(i, b)| b.label.map(|l| (i, l))) + .find(|(_, l)| *l == id); + match idx { + Some((idx, _)) => { + *label = Index::Num(idx as u32, id.span()); + Ok(()) + } + None => Err(resolve_error(id, "label")), + } + } +} + +enum TypeInfo<'a> { + Func { + params: Box<[ValType<'a>]>, + results: Box<[ValType<'a>]>, + }, + Other, +} + +trait TypeReference<'a> { + fn check_matches(&mut self, idx: &Index<'a>, cx: &Resolver<'a>) -> Result<(), Error>; + fn resolve(&mut self, cx: &Resolver<'a>) -> Result<(), Error>; +} + +impl<'a> TypeReference<'a> for FunctionType<'a> { + fn check_matches(&mut self, idx: &Index<'a>, cx: &Resolver<'a>) -> Result<(), Error> { + let n = match idx { + Index::Num(n, _) => *n, + Index::Id(_) => panic!("expected `Num`"), + }; + let (params, results) = match cx.type_info.get(n as usize) { + Some(TypeInfo::Func { params, results }) => (params, results), + _ => return Ok(()), + }; + + // Here we need to check that the inline type listed (ourselves) matches + // what was listed in the module itself (the `params` and `results` + // above). The listed values in `types` are not resolved yet, although + // we should be resolved. In any case we do name resolution + // opportunistically here to see if the values are equal. + + let types_not_equal = |a: &ValType, b: &ValType| { + let mut a = a.clone(); + let mut b = b.clone(); + drop(cx.resolve_valtype(&mut a)); + drop(cx.resolve_valtype(&mut b)); + a != b + }; + + let not_equal = params.len() != self.params.len() + || results.len() != self.results.len() + || params + .iter() + .zip(self.params.iter()) + .any(|(a, (_, _, b))| types_not_equal(a, b)) + || results + .iter() + .zip(self.results.iter()) + .any(|(a, b)| types_not_equal(a, b)); + if not_equal { + return Err(Error::new( + idx.span(), + format!("inline function type doesn't match type reference"), + )); + } + + Ok(()) + } + + fn resolve(&mut self, cx: &Resolver<'a>) -> Result<(), Error> { + // Resolve the (ref T) value types in the final function type + for param in self.params.iter_mut() { + cx.resolve_valtype(&mut param.2)?; + } + for result in self.results.iter_mut() { + cx.resolve_valtype(result)?; + } + Ok(()) + } +} diff --git a/crates/wastlhw/src/core/resolve/types.rs b/crates/wastlhw/src/core/resolve/types.rs new file mode 100644 index 000000000..38af9e680 --- /dev/null +++ b/crates/wastlhw/src/core/resolve/types.rs @@ -0,0 +1,261 @@ +use crate::core::*; +use crate::gensym; +use crate::token::{Index, Span}; +use std::collections::HashMap; + +pub fn expand<'a>(fields: &mut Vec>) { + let mut expander = Expander::default(); + expander.process(fields); +} + +#[derive(Default)] +pub(crate) struct Expander<'a> { + // Maps used to "intern" types. These maps are populated as type annotations + // are seen and inline type annotations use previously defined ones if + // there's a match. + func_type_to_idx: HashMap, Index<'a>>, + + /// Fields, during processing, which should be prepended to the + /// currently-being-processed field. This should always be empty after + /// processing is complete. + to_prepend: Vec>, +} + +impl<'a> Expander<'a> { + fn process(&mut self, fields: &mut Vec>) { + // Next we expand "header" fields which are those like types and + // imports. In this context "header" is defined by the previous + // `process_imports_early` annotation. + let mut cur = 0; + while cur < fields.len() { + self.expand_header(&mut fields[cur]); + for item in self.to_prepend.drain(..) { + fields.insert(cur, item); + cur += 1; + } + cur += 1; + } + + // Next after we've done that we expand remaining fields. Note that + // after this we actually append instead of prepend. This is because + // injected types are intended to come at the end of the type section + // and types will be sorted before all other items processed here in the + // final module anyway. + for field in fields.iter_mut() { + self.expand(field); + } + fields.append(&mut self.to_prepend); + } + + fn expand_header(&mut self, item: &mut ModuleField<'a>) { + match item { + ModuleField::Type(ty) => { + let id = gensym::fill(ty.span, &mut ty.id); + match &mut ty.def { + TypeDef::Func(f) => { + f.key().insert(self, Index::Id(id)); + } + TypeDef::Array(_) | TypeDef::Struct(_) => {} + } + } + _ => {} + } + } + + fn expand(&mut self, item: &mut ModuleField<'a>) { + match item { + // This is pre-expanded above + ModuleField::Type(_) => {} + ModuleField::Rec(_) => {} + + ModuleField::Import(i) => { + self.expand_item_sig(&mut i.item); + } + ModuleField::Func(f) => { + self.expand_type_use(&mut f.ty); + if let FuncKind::Inline { expression, .. } = &mut f.kind { + self.expand_expression(expression); + } + } + ModuleField::Global(g) => { + if let GlobalKind::Inline(expr) = &mut g.kind { + self.expand_expression(expr); + } + } + ModuleField::Data(d) => { + if let DataKind::Active { offset, .. } = &mut d.kind { + self.expand_expression(offset); + } + } + ModuleField::Elem(e) => { + if let ElemKind::Active { offset, .. } = &mut e.kind { + self.expand_expression(offset); + } + if let ElemPayload::Exprs { exprs, .. } = &mut e.payload { + for expr in exprs { + self.expand_expression(expr); + } + } + } + ModuleField::Tag(t) => match &mut t.ty { + TagType::Exception(ty) => { + self.expand_type_use(ty); + } + }, + + ModuleField::Table(_) + | ModuleField::Memory(_) + | ModuleField::Start(_) + | ModuleField::Export(_) + | ModuleField::Custom(_) => {} + } + } + + fn expand_item_sig(&mut self, item: &mut ItemSig<'a>) { + match &mut item.kind { + ItemKind::Func(t) | ItemKind::Tag(TagType::Exception(t)) => { + self.expand_type_use(t); + } + ItemKind::Global(_) | ItemKind::Table(_) | ItemKind::Memory(_) => {} + } + } + + fn expand_expression(&mut self, expr: &mut Expression<'a>) { + for instr in expr.instrs.iter_mut() { + self.expand_instr(instr); + } + } + + fn expand_instr(&mut self, instr: &mut Instruction<'a>) { + match instr { + Instruction::Block(bt) + | Instruction::If(bt) + | Instruction::Loop(bt) + | Instruction::Let(LetType { block: bt, .. }) + | Instruction::Try(bt) => { + // No expansion necessary, a type reference is already here. + // We'll verify that it's the same as the inline type, if any, + // later. + if bt.ty.index.is_some() { + return; + } + + match &bt.ty.inline { + // Only actually expand `TypeUse` with an index which appends a + // type if it looks like we need one. This way if the + // multi-value proposal isn't enabled and/or used we won't + // encode it. + Some(inline) => { + if inline.params.len() == 0 && inline.results.len() <= 1 { + return; + } + } + + // If we didn't have either an index or an inline type + // listed then assume our block has no inputs/outputs, so + // fill in the inline type here. + // + // Do not fall through to expanding the `TypeUse` because + // this doesn't force an empty function type to go into the + // type section. + None => { + bt.ty.inline = Some(FunctionType::default()); + return; + } + } + self.expand_type_use(&mut bt.ty); + } + Instruction::FuncBind(b) => { + self.expand_type_use(&mut b.ty); + } + Instruction::CallIndirect(c) | Instruction::ReturnCallIndirect(c) => { + self.expand_type_use(&mut c.ty); + } + _ => {} + } + } + + fn expand_type_use(&mut self, item: &mut TypeUse<'a, T>) -> Index<'a> + where + T: TypeReference<'a>, + { + if let Some(idx) = &item.index { + return *idx; + } + let key = match item.inline.as_mut() { + Some(ty) => { + ty.expand(self); + ty.key() + } + None => T::default().key(), + }; + let span = Span::from_offset(0); // FIXME(#613): don't manufacture + let idx = self.key_to_idx(span, key); + item.index = Some(idx); + idx + } + + fn key_to_idx(&mut self, span: Span, key: impl TypeKey<'a>) -> Index<'a> { + // First see if this `key` already exists in the type definitions we've + // seen so far... + if let Some(idx) = key.lookup(self) { + return idx; + } + + // ... and failing that we insert a new type definition. + let id = gensym::gen(span); + self.to_prepend.push(ModuleField::Type(Type { + span, + id: Some(id), + name: None, + def: key.to_def(span), + parent: None, + })); + let idx = Index::Id(id); + key.insert(self, idx); + idx + } +} + +pub(crate) trait TypeReference<'a>: Default { + type Key: TypeKey<'a>; + fn key(&self) -> Self::Key; + fn expand(&mut self, cx: &mut Expander<'a>); +} + +pub(crate) trait TypeKey<'a> { + fn lookup(&self, cx: &Expander<'a>) -> Option>; + fn to_def(&self, span: Span) -> TypeDef<'a>; + fn insert(&self, cx: &mut Expander<'a>, id: Index<'a>); +} + +pub(crate) type FuncKey<'a> = (Box<[ValType<'a>]>, Box<[ValType<'a>]>); + +impl<'a> TypeReference<'a> for FunctionType<'a> { + type Key = FuncKey<'a>; + + fn key(&self) -> Self::Key { + let params = self.params.iter().map(|p| p.2).collect(); + let results = self.results.clone(); + (params, results) + } + + fn expand(&mut self, _cx: &mut Expander<'a>) {} +} + +impl<'a> TypeKey<'a> for FuncKey<'a> { + fn lookup(&self, cx: &Expander<'a>) -> Option> { + cx.func_type_to_idx.get(self).cloned() + } + + fn to_def(&self, _span: Span) -> TypeDef<'a> { + TypeDef::Func(FunctionType { + params: self.0.iter().map(|t| (None, None, *t)).collect(), + results: self.1.clone(), + }) + } + + fn insert(&self, cx: &mut Expander<'a>, idx: Index<'a>) { + cx.func_type_to_idx.entry(self.clone()).or_insert(idx); + } +} diff --git a/crates/wastlhw/src/core/table.rs b/crates/wastlhw/src/core/table.rs new file mode 100644 index 000000000..005bfe204 --- /dev/null +++ b/crates/wastlhw/src/core/table.rs @@ -0,0 +1,229 @@ +use crate::core::*; +use crate::kw; +use crate::parser::{Parse, Parser, Result}; +use crate::token::{Id, Index, LParen, NameAnnotation, Span}; + +/// A WebAssembly `table` directive in a module. +#[derive(Debug)] +pub struct Table<'a> { + /// Where this table was defined. + pub span: Span, + /// An optional name to refer to this table by. + pub id: Option>, + /// An optional name for this function stored in the custom `name` section. + pub name: Option>, + /// If present, inline export annotations which indicate names this + /// definition should be exported under. + pub exports: InlineExport<'a>, + /// How this table is textually defined in the module. + pub kind: TableKind<'a>, +} + +/// Different ways to textually define a table. +#[derive(Debug)] +pub enum TableKind<'a> { + /// This table is actually an inlined import definition. + #[allow(missing_docs)] + Import { + import: InlineImport<'a>, + ty: TableType<'a>, + }, + + /// A typical memory definition which simply says the limits of the table + Normal(TableType<'a>), + + /// The elem segments of this table, starting from 0, explicitly listed + Inline { + /// The element type of this table. + elem: RefType<'a>, + /// The element table entries to have, and the length of this list is + /// the limits of the table as well. + payload: ElemPayload<'a>, + }, +} + +impl<'a> Parse<'a> for Table<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let id = parser.parse()?; + let name = parser.parse()?; + let exports = parser.parse()?; + + // Afterwards figure out which style this is, either: + // + // * `elemtype (elem ...)` + // * `(import "a" "b") limits` + // * `limits` + let mut l = parser.lookahead1(); + let kind = if l.peek::() { + let elem = parser.parse()?; + let payload = parser.parens(|p| { + p.parse::()?; + let ty = if parser.peek::() { + Some(elem) + } else { + None + }; + ElemPayload::parse_tail(parser, ty) + })?; + TableKind::Inline { elem, payload } + } else if l.peek::() { + TableKind::Normal(parser.parse()?) + } else if let Some(import) = parser.parse()? { + TableKind::Import { + import, + ty: parser.parse()?, + } + } else { + return Err(l.error()); + }; + Ok(Table { + span, + id, + name, + exports, + kind, + }) + } +} + +/// An `elem` segment in a WebAssembly module. +#[derive(Debug)] +pub struct Elem<'a> { + /// Where this `elem` was defined. + pub span: Span, + /// An optional name by which to refer to this segment. + pub id: Option>, + /// An optional name for this element stored in the custom `name` section. + pub name: Option>, + /// The way this segment was defined in the module. + pub kind: ElemKind<'a>, + /// The payload of this element segment, typically a list of functions. + pub payload: ElemPayload<'a>, +} + +/// Different ways to define an element segment in an mdoule. +#[derive(Debug)] +pub enum ElemKind<'a> { + /// A passive segment that isn't associated with a table and can be used in + /// various bulk-memory instructions. + Passive, + + /// A declared element segment that is purely used to declare function + /// references. + Declared, + + /// An active segment associated with a table. + Active { + /// The table this `elem` is initializing. + table: Index<'a>, + /// The offset within `table` that we'll initialize at. + offset: Expression<'a>, + }, +} + +/// Different ways to define the element segment payload in a module. +#[derive(Debug)] +pub enum ElemPayload<'a> { + /// This element segment has a contiguous list of function indices + Indices(Vec>), + + /// This element segment has a list of optional function indices, + /// represented as expressions using `ref.func` and `ref.null`. + Exprs { + /// The desired type of each expression below. + ty: RefType<'a>, + /// The expressions in this segment. + exprs: Vec>, + }, +} + +impl<'a> Parse<'a> for Elem<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let id = parser.parse()?; + let name = parser.parse()?; + + let kind = if parser.peek::() { + parser.parse::()?; + ElemKind::Declared + } else if parser.peek::() || (parser.peek::() && !parser.peek::()) { + let table = if parser.peek::() { + // FIXME: this is only here to accomodate + // proposals/threads/imports.wast at this current moment in + // time, this probably should get removed when the threads + // proposal is rebased on the current spec. + Index::Num(parser.parse()?, span) + } else if parser.peek2::() { + parser.parens(|p| { + p.parse::()?; + p.parse() + })? + } else { + Index::Num(0, span) + }; + let offset = parser.parens(|parser| { + if parser.peek::() { + parser.parse::()?; + } + parser.parse() + })?; + ElemKind::Active { table, offset } + } else { + ElemKind::Passive + }; + let payload = parser.parse()?; + Ok(Elem { + span, + id, + name, + kind, + payload, + }) + } +} + +impl<'a> Parse<'a> for ElemPayload<'a> { + fn parse(parser: Parser<'a>) -> Result { + ElemPayload::parse_tail(parser, parser.parse()?) + } +} + +impl<'a> ElemPayload<'a> { + fn parse_tail(parser: Parser<'a>, ty: Option>) -> Result { + let (must_use_indices, ty) = match ty { + None => { + parser.parse::>()?; + (true, RefType::func()) + } + Some(ty) => (false, ty), + }; + if let HeapType::Func = ty.heap { + if must_use_indices || parser.peek::>() { + let mut elems = Vec::new(); + while !parser.is_empty() { + elems.push(parser.parse()?); + } + return Ok(ElemPayload::Indices(elems)); + } + } + let mut exprs = Vec::new(); + while !parser.is_empty() { + let expr = parser.parens(|parser| { + if parser.peek::() { + parser.parse::()?; + parser.parse() + } else { + // Without `item` this is "sugar" for a single-instruction + // expression. + let insn = parser.parse()?; + Ok(Expression { + instrs: [insn].into(), + }) + } + })?; + exprs.push(expr); + } + Ok(ElemPayload::Exprs { exprs, ty }) + } +} diff --git a/crates/wastlhw/src/core/tag.rs b/crates/wastlhw/src/core/tag.rs new file mode 100644 index 000000000..233b5e4cd --- /dev/null +++ b/crates/wastlhw/src/core/tag.rs @@ -0,0 +1,71 @@ +use crate::core::*; +use crate::kw; +use crate::parser::{Parse, Parser, Result}; +use crate::token::{Id, NameAnnotation, Span}; + +/// A WebAssembly tag directive, part of the exception handling proposal. +#[derive(Debug)] +pub struct Tag<'a> { + /// Where this tag was defined + pub span: Span, + /// An optional name by which to refer to this tag in name resolution. + pub id: Option>, + /// An optional name for this function stored in the custom `name` section. + pub name: Option>, + /// Optional export directives for this tag. + pub exports: InlineExport<'a>, + /// The type of tag that is defined. + pub ty: TagType<'a>, + /// What kind of tag this is defined as. + pub kind: TagKind<'a>, +} + +/// Listing of various types of tags that can be defined in a wasm module. +#[derive(Clone, Debug)] +pub enum TagType<'a> { + /// An exception tag, where the payload is the type signature of the tag + /// (constructor parameters, etc). + Exception(TypeUse<'a, FunctionType<'a>>), +} + +/// Different kinds of tags that can be defined in a module. +#[derive(Debug)] +pub enum TagKind<'a> { + /// An tag which is actually defined as an import, such as: + /// + /// ```text + /// (tag (type 0) (import "foo" "bar")) + /// ``` + Import(InlineImport<'a>), + + /// A tag defined inline in the module itself + Inline(), +} + +impl<'a> Parse<'a> for Tag<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let id = parser.parse()?; + let name = parser.parse()?; + let exports = parser.parse()?; + let (ty, kind) = if let Some(import) = parser.parse()? { + (parser.parse()?, TagKind::Import(import)) + } else { + (parser.parse()?, TagKind::Inline()) + }; + Ok(Tag { + span, + id, + name, + exports, + ty, + kind, + }) + } +} + +impl<'a> Parse<'a> for TagType<'a> { + fn parse(parser: Parser<'a>) -> Result { + Ok(TagType::Exception(parser.parse()?)) + } +} diff --git a/crates/wastlhw/src/core/types.rs b/crates/wastlhw/src/core/types.rs new file mode 100644 index 000000000..f3870f5b6 --- /dev/null +++ b/crates/wastlhw/src/core/types.rs @@ -0,0 +1,779 @@ +use crate::core::*; +use crate::kw; +use crate::parser::{Cursor, Parse, Parser, Peek, Result}; +use crate::token::{Id, Index, LParen, NameAnnotation, Span}; +use std::mem; + +/// The value types for a wasm module. +#[allow(missing_docs)] +#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)] +pub enum ValType<'a> { + I32, + I64, + F32, + F64, + V128, + Ref(RefType<'a>), +} + +impl<'a> Parse<'a> for ValType<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + Ok(ValType::I32) + } else if l.peek::() { + parser.parse::()?; + Ok(ValType::I64) + } else if l.peek::() { + parser.parse::()?; + Ok(ValType::F32) + } else if l.peek::() { + parser.parse::()?; + Ok(ValType::F64) + } else if l.peek::() { + parser.parse::()?; + Ok(ValType::V128) + } else if l.peek::() { + Ok(ValType::Ref(parser.parse()?)) + } else { + Err(l.error()) + } + } +} + +impl<'a> Peek for ValType<'a> { + fn peek(cursor: Cursor<'_>) -> bool { + kw::i32::peek(cursor) + || kw::i64::peek(cursor) + || kw::f32::peek(cursor) + || kw::f64::peek(cursor) + || kw::v128::peek(cursor) + || RefType::peek(cursor) + } + fn display() -> &'static str { + "valtype" + } +} + +/// A heap type for a reference type +#[allow(missing_docs)] +#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)] +pub enum HeapType<'a> { + /// An untyped function reference: funcref. This is part of the reference + /// types proposal. + Func, + /// A reference to any host value: externref. This is part of the reference + /// types proposal. + Extern, + /// A reference to any reference value: anyref. This is part of the GC + /// proposal. + Any, + /// A reference that has an identity that can be compared: eqref. This is + /// part of the GC proposal. + Eq, + /// A reference to a GC object. This is part of the GC proposal. + Data, + /// A reference to a GC array. This is part of the GC proposal. + Array, + /// An unboxed 31-bit integer: i31ref. This may be going away if there is no common + /// supertype of all reference types. Part of the GC proposal. + I31, + /// A reference to a function, struct, or array: ref T. This is part of the + /// GC proposal. + Index(Index<'a>), +} + +impl<'a> Parse<'a> for HeapType<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + Ok(HeapType::Func) + } else if l.peek::() { + parser.parse::()?; + Ok(HeapType::Extern) + } else if l.peek::() { + parser.parse::()?; + Ok(HeapType::Any) + } else if l.peek::() { + parser.parse::()?; + Ok(HeapType::Eq) + } else if l.peek::() { + parser.parse::()?; + Ok(HeapType::Data) + } else if l.peek::() { + parser.parse::()?; + Ok(HeapType::Array) + } else if l.peek::() { + parser.parse::()?; + Ok(HeapType::I31) + } else if l.peek::() { + Ok(HeapType::Index(parser.parse()?)) + } else { + Err(l.error()) + } + } +} + +impl<'a> Peek for HeapType<'a> { + fn peek(cursor: Cursor<'_>) -> bool { + kw::func::peek(cursor) + || kw::r#extern::peek(cursor) + || kw::any::peek(cursor) + || kw::eq::peek(cursor) + || kw::data::peek(cursor) + || kw::array::peek(cursor) + || kw::i31::peek(cursor) + || (LParen::peek(cursor) && kw::r#type::peek2(cursor)) + } + fn display() -> &'static str { + "heaptype" + } +} + +/// A reference type in a wasm module. +#[allow(missing_docs)] +#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)] +pub struct RefType<'a> { + pub nullable: bool, + pub heap: HeapType<'a>, +} + +impl<'a> RefType<'a> { + /// A `funcref` as an abbreviation for `(ref null func)`. + pub fn func() -> Self { + RefType { + nullable: true, + heap: HeapType::Func, + } + } + + /// An `externref` as an abbreviation for `(ref null extern)`. + pub fn r#extern() -> Self { + RefType { + nullable: true, + heap: HeapType::Extern, + } + } + + /// An `anyref` as an abbreviation for `(ref null any)`. + pub fn any() -> Self { + RefType { + nullable: true, + heap: HeapType::Any, + } + } + + /// An `eqref` as an abbreviation for `(ref null eq)`. + pub fn eq() -> Self { + RefType { + nullable: true, + heap: HeapType::Eq, + } + } + + /// An `dataref` as an abbreviation for `(ref null data)`. + pub fn data() -> Self { + RefType { + nullable: true, + heap: HeapType::Data, + } + } + + /// An `arrayref` as an abbreviation for `(ref null array)`. + pub fn array() -> Self { + RefType { + nullable: true, + heap: HeapType::Array, + } + } + + /// An `i31ref` as an abbreviation for `(ref null i31)`. + pub fn i31() -> Self { + RefType { + nullable: true, + heap: HeapType::I31, + } + } +} + +impl<'a> Parse<'a> for RefType<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + Ok(RefType::func()) + } else if l.peek::() { + parser.parse::()?; + Ok(RefType::func()) + } else if l.peek::() { + parser.parse::()?; + Ok(RefType::r#extern()) + } else if l.peek::() { + parser.parse::()?; + Ok(RefType::any()) + } else if l.peek::() { + parser.parse::()?; + Ok(RefType::eq()) + } else if l.peek::() { + parser.parse::()?; + Ok(RefType::data()) + } else if l.peek::() { + parser.parse::()?; + Ok(RefType::array()) + } else if l.peek::() { + parser.parse::()?; + Ok(RefType::i31()) + } else if l.peek::() { + parser.parens(|p| { + let mut l = parser.lookahead1(); + if l.peek::() { + p.parse::()?; + + let mut nullable = false; + if parser.peek::() { + parser.parse::()?; + nullable = true; + } + + Ok(RefType { + nullable, + heap: parser.parse()?, + }) + } else { + Err(l.error()) + } + }) + } else { + Err(l.error()) + } + } +} + +impl<'a> Peek for RefType<'a> { + fn peek(cursor: Cursor<'_>) -> bool { + kw::funcref::peek(cursor) + || /* legacy */ kw::anyfunc::peek(cursor) + || kw::externref::peek(cursor) + || kw::anyref::peek(cursor) + || kw::eqref::peek(cursor) + || kw::dataref::peek(cursor) + || kw::arrayref::peek(cursor) + || kw::i31ref::peek(cursor) + || (LParen::peek(cursor) && kw::r#ref::peek2(cursor)) + } + fn display() -> &'static str { + "reftype" + } +} + +/// The types of values that may be used in a struct or array. +#[allow(missing_docs)] +#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)] +pub enum StorageType<'a> { + I8, + I16, + Val(ValType<'a>), +} + +impl<'a> Parse<'a> for StorageType<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + Ok(StorageType::I8) + } else if l.peek::() { + parser.parse::()?; + Ok(StorageType::I16) + } else if l.peek::() { + Ok(StorageType::Val(parser.parse()?)) + } else { + Err(l.error()) + } + } +} + +/// Type for a `global` in a wasm module +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +pub struct GlobalType<'a> { + /// The element type of this `global` + pub ty: ValType<'a>, + /// Whether or not the global is mutable or not. + pub mutable: bool, +} + +impl<'a> Parse<'a> for GlobalType<'a> { + fn parse(parser: Parser<'a>) -> Result { + if parser.peek2::() { + parser.parens(|p| { + p.parse::()?; + Ok(GlobalType { + ty: parser.parse()?, + mutable: true, + }) + }) + } else { + Ok(GlobalType { + ty: parser.parse()?, + mutable: false, + }) + } + } +} + +/// Min/max limits used for tables/memories. +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +pub struct Limits { + /// The minimum number of units for this type. + pub min: u32, + /// An optional maximum number of units for this type. + pub max: Option, +} + +impl<'a> Parse<'a> for Limits { + fn parse(parser: Parser<'a>) -> Result { + let min = parser.parse()?; + let max = if parser.peek::() { + Some(parser.parse()?) + } else { + None + }; + Ok(Limits { min, max }) + } +} + +/// Min/max limits used for 64-bit memories +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +pub struct Limits64 { + /// The minimum number of units for this type. + pub min: u64, + /// An optional maximum number of units for this type. + pub max: Option, +} + +impl<'a> Parse<'a> for Limits64 { + fn parse(parser: Parser<'a>) -> Result { + let min = parser.parse()?; + let max = if parser.peek::() { + Some(parser.parse()?) + } else { + None + }; + Ok(Limits64 { min, max }) + } +} + +/// Configuration for a table of a wasm mdoule +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +pub struct TableType<'a> { + /// Limits on the element sizes of this table + pub limits: Limits, + /// The type of element stored in this table + pub elem: RefType<'a>, +} + +impl<'a> Parse<'a> for TableType<'a> { + fn parse(parser: Parser<'a>) -> Result { + Ok(TableType { + limits: parser.parse()?, + elem: parser.parse()?, + }) + } +} + +/// Configuration for a memory of a wasm module +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +pub enum MemoryType { + /// A 32-bit memory + B32 { + /// Limits on the page sizes of this memory + limits: Limits, + /// Whether or not this is a shared (atomic) memory type + shared: bool, + }, + /// A 64-bit memory + B64 { + /// Limits on the page sizes of this memory + limits: Limits64, + /// Whether or not this is a shared (atomic) memory type + shared: bool, + }, +} + +impl<'a> Parse<'a> for MemoryType { + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::() { + parser.parse::()?; + let limits = parser.parse()?; + let shared = parser.parse::>()?.is_some(); + Ok(MemoryType::B64 { limits, shared }) + } else { + parser.parse::>()?; + let limits = parser.parse()?; + let shared = parser.parse::>()?.is_some(); + Ok(MemoryType::B32 { limits, shared }) + } + } +} + +/// A function type with parameters and results. +#[derive(Clone, Debug, Default)] +pub struct FunctionType<'a> { + /// The parameters of a function, optionally each having an identifier for + /// name resolution and a name for the custom `name` section. + pub params: Box<[(Option>, Option>, ValType<'a>)]>, + /// The results types of a function. + pub results: Box<[ValType<'a>]>, +} + +impl<'a> FunctionType<'a> { + fn finish_parse(&mut self, allow_names: bool, parser: Parser<'a>) -> Result<()> { + let mut params = Vec::from(mem::take(&mut self.params)); + let mut results = Vec::from(mem::take(&mut self.results)); + while parser.peek2::() || parser.peek2::() { + parser.parens(|p| { + let mut l = p.lookahead1(); + if l.peek::() { + if results.len() > 0 { + return Err(p.error( + "result before parameter (or unexpected token): \ + cannot list params after results", + )); + } + p.parse::()?; + if p.is_empty() { + return Ok(()); + } + let (id, name) = if allow_names { + (p.parse::>()?, p.parse::>()?) + } else { + (None, None) + }; + let parse_more = id.is_none() && name.is_none(); + let ty = p.parse()?; + params.push((id, name, ty)); + while parse_more && !p.is_empty() { + params.push((None, None, p.parse()?)); + } + } else if l.peek::() { + p.parse::()?; + while !p.is_empty() { + results.push(p.parse()?); + } + } else { + return Err(l.error()); + } + Ok(()) + })?; + } + self.params = params.into(); + self.results = results.into(); + Ok(()) + } +} + +impl<'a> Parse<'a> for FunctionType<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut ret = FunctionType { + params: Box::new([]), + results: Box::new([]), + }; + ret.finish_parse(true, parser)?; + Ok(ret) + } +} + +impl<'a> Peek for FunctionType<'a> { + fn peek(cursor: Cursor<'_>) -> bool { + if let Some(next) = cursor.lparen() { + match next.keyword() { + Some(("param", _)) | Some(("result", _)) => return true, + _ => {} + } + } + + false + } + + fn display() -> &'static str { + "function type" + } +} + +/// A function type with parameters and results. +#[derive(Clone, Debug, Default)] +pub struct FunctionTypeNoNames<'a>(pub FunctionType<'a>); + +impl<'a> Parse<'a> for FunctionTypeNoNames<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut ret = FunctionType { + params: Box::new([]), + results: Box::new([]), + }; + ret.finish_parse(false, parser)?; + Ok(FunctionTypeNoNames(ret)) + } +} + +impl<'a> Peek for FunctionTypeNoNames<'a> { + fn peek(cursor: Cursor<'_>) -> bool { + FunctionType::peek(cursor) + } + + fn display() -> &'static str { + FunctionType::display() + } +} + +impl<'a> From> for FunctionType<'a> { + fn from(ty: FunctionTypeNoNames<'a>) -> FunctionType<'a> { + ty.0 + } +} + +/// A struct type with fields. +#[derive(Clone, Debug)] +pub struct StructType<'a> { + /// The fields of the struct + pub fields: Vec>, +} + +impl<'a> Parse<'a> for StructType<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut ret = StructType { fields: Vec::new() }; + while !parser.is_empty() { + let field = if parser.peek2::() { + parser.parens(|parser| { + parser.parse::()?; + StructField::parse(parser, true) + }) + } else { + StructField::parse(parser, false) + }; + ret.fields.push(field?); + } + Ok(ret) + } +} + +/// A field of a struct type. +#[derive(Clone, Debug)] +pub struct StructField<'a> { + /// An optional identifier for name resolution. + pub id: Option>, + /// Whether this field may be mutated or not. + pub mutable: bool, + /// The storage type stored in this field. + pub ty: StorageType<'a>, +} + +impl<'a> StructField<'a> { + fn parse(parser: Parser<'a>, with_id: bool) -> Result { + let id = if with_id { parser.parse()? } else { None }; + let (ty, mutable) = if parser.peek2::() { + let ty = parser.parens(|parser| { + parser.parse::()?; + parser.parse() + })?; + (ty, true) + } else { + (parser.parse::>()?, false) + }; + Ok(StructField { id, mutable, ty }) + } +} + +/// An array type with fields. +#[derive(Clone, Debug)] +pub struct ArrayType<'a> { + /// Whether this field may be mutated or not. + pub mutable: bool, + /// The storage type stored in this field. + pub ty: StorageType<'a>, +} + +impl<'a> Parse<'a> for ArrayType<'a> { + fn parse(parser: Parser<'a>) -> Result { + let (ty, mutable) = if parser.peek2::() { + let ty = parser.parens(|parser| { + parser.parse::()?; + parser.parse() + })?; + (ty, true) + } else { + (parser.parse::>()?, false) + }; + Ok(ArrayType { mutable, ty }) + } +} + +/// The type of an exported item from a module or instance. +#[derive(Debug, Clone)] +pub struct ExportType<'a> { + /// Where this export was defined. + pub span: Span, + /// The name of this export. + pub name: &'a str, + /// The signature of the item that's exported. + pub item: ItemSig<'a>, +} + +impl<'a> Parse<'a> for ExportType<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let name = parser.parse()?; + let item = parser.parens(|p| p.parse())?; + Ok(ExportType { span, name, item }) + } +} + +/// A definition of a type. +#[derive(Debug)] +pub enum TypeDef<'a> { + /// A function type definition. + Func(FunctionType<'a>), + /// A struct type definition. + Struct(StructType<'a>), + /// An array type definition. + Array(ArrayType<'a>), +} + +impl<'a> Parse<'a> for TypeDef<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + Ok(TypeDef::Func(parser.parse()?)) + } else if l.peek::() { + parser.parse::()?; + Ok(TypeDef::Struct(parser.parse()?)) + } else if l.peek::() { + parser.parse::()?; + Ok(TypeDef::Array(parser.parse()?)) + } else { + Err(l.error()) + } + } +} + +/// A type declaration in a module +#[derive(Debug)] +pub struct Type<'a> { + /// Where this type was defined. + pub span: Span, + /// An optional identifier to refer to this `type` by as part of name + /// resolution. + pub id: Option>, + /// An optional name for this function stored in the custom `name` section. + pub name: Option>, + /// The type that we're declaring. + pub def: TypeDef<'a>, + /// The declared parent type of this definition. + pub parent: Option>, +} + +impl<'a> Type<'a> { + fn parse_inner(parser: Parser<'a>, parent: Option>) -> Result { + let span = parser.parse::()?.0; + let id = parser.parse()?; + let name = parser.parse()?; + let def = parser.parens(|parser| parser.parse())?; + Ok(Type { + span, + id, + name, + def, + parent, + }) + } +} + +impl<'a> Peek for Type<'a> { + fn peek(cursor: Cursor<'_>) -> bool { + kw::r#type::peek(cursor) || kw::sub::peek(cursor) + } + fn display() -> &'static str { + "type" + } +} + +impl<'a> Parse<'a> for Type<'a> { + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::() { + parser.parse::()?; + let parent = if parser.peek::>() { + parser.parse()? + } else { + None + }; + return parser.parens(|parser| Type::parse_inner(parser, parent)); + } + Type::parse_inner(parser, None) + } +} + +/// A recursion group declaration in a module +#[derive(Debug)] +pub struct Rec<'a> { + /// Where this recursion group was defined. + pub span: Span, + /// The types that we're defining in this group. + pub types: Vec>, +} + +impl<'a> Parse<'a> for Rec<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let mut types = Vec::new(); + while parser.peek2::>() { + types.push(parser.parens(|p| p.parse())?); + } + Ok(Rec { span, types }) + } +} + +/// A reference to a type defined in this module. +#[derive(Clone, Debug)] +pub struct TypeUse<'a, T> { + /// The type that we're referencing, if it was present. + pub index: Option>, + /// The inline type, if present. + pub inline: Option, +} + +impl<'a, T> TypeUse<'a, T> { + /// Constructs a new instance of `TypeUse` without an inline definition but + /// with an index specified. + pub fn new_with_index(idx: Index<'a>) -> TypeUse<'a, T> { + TypeUse { + index: Some(idx), + inline: None, + } + } +} + +impl<'a, T: Peek + Parse<'a>> Parse<'a> for TypeUse<'a, T> { + fn parse(parser: Parser<'a>) -> Result { + let index = if parser.peek2::() { + Some(parser.parens(|p| { + p.parse::()?; + p.parse() + })?) + } else { + None + }; + let inline = parser.parse()?; + + Ok(TypeUse { index, inline }) + } +} + +impl<'a> From>> for TypeUse<'a, FunctionType<'a>> { + fn from(src: TypeUse<'a, FunctionTypeNoNames<'a>>) -> TypeUse<'a, FunctionType<'a>> { + TypeUse { + index: src.index, + inline: src.inline.map(|x| x.into()), + } + } +} diff --git a/crates/wastlhw/src/core/wast.rs b/crates/wastlhw/src/core/wast.rs new file mode 100644 index 000000000..5780b9de4 --- /dev/null +++ b/crates/wastlhw/src/core/wast.rs @@ -0,0 +1,226 @@ +use crate::core::{HeapType, V128Const}; +use crate::kw; +use crate::parser::{Cursor, Parse, Parser, Peek, Result}; +use crate::token::{Float32, Float64, Index}; + +/// Expression that can be used inside of `invoke` expressions for core wasm +/// functions. +#[derive(Debug)] +#[allow(missing_docs)] +pub enum WastArgCore<'a> { + I32(i32), + I64(i64), + F32(Float32), + F64(Float64), + V128(V128Const), + RefNull(HeapType<'a>), + RefExtern(u32), +} + +static ARGS: &[(&str, fn(Parser<'_>) -> Result>)] = { + use WastArgCore::*; + &[ + ("i32.const", |p| Ok(I32(p.parse()?))), + ("i64.const", |p| Ok(I64(p.parse()?))), + ("f32.const", |p| Ok(F32(p.parse()?))), + ("f64.const", |p| Ok(F64(p.parse()?))), + ("v128.const", |p| Ok(V128(p.parse()?))), + ("ref.null", |p| Ok(RefNull(p.parse()?))), + ("ref.extern", |p| Ok(RefExtern(p.parse()?))), + ] +}; + +impl<'a> Parse<'a> for WastArgCore<'a> { + fn parse(parser: Parser<'a>) -> Result { + let parse = parser.step(|c| { + if let Some((kw, rest)) = c.keyword() { + if let Some(i) = ARGS.iter().position(|(name, _)| *name == kw) { + return Ok((ARGS[i].1, rest)); + } + } + Err(c.error("expected a [type].const expression")) + })?; + parse(parser) + } +} + +impl Peek for WastArgCore<'_> { + fn peek(cursor: Cursor<'_>) -> bool { + let kw = match cursor.keyword() { + Some((kw, _)) => kw, + None => return false, + }; + ARGS.iter().find(|(name, _)| *name == kw).is_some() + } + + fn display() -> &'static str { + "core wasm argument" + } +} + +/// Expressions that can be used inside of `assert_return` to validate the +/// return value of a core wasm function. +#[derive(Debug)] +#[allow(missing_docs)] +pub enum WastRetCore<'a> { + I32(i32), + I64(i64), + F32(NanPattern), + F64(NanPattern), + V128(V128Pattern), + + /// A null reference is expected, optionally with a specified type. + RefNull(Option>), + /// A non-null externref is expected which should contain the specified + /// value. + RefExtern(u32), + /// A non-null funcref is expected. + RefFunc(Option>), +} + +static RETS: &[(&str, fn(Parser<'_>) -> Result>)] = { + use WastRetCore::*; + &[ + ("i32.const", |p| Ok(I32(p.parse()?))), + ("i64.const", |p| Ok(I64(p.parse()?))), + ("f32.const", |p| Ok(F32(p.parse()?))), + ("f64.const", |p| Ok(F64(p.parse()?))), + ("v128.const", |p| Ok(V128(p.parse()?))), + ("ref.null", |p| Ok(RefNull(p.parse()?))), + ("ref.extern", |p| Ok(RefExtern(p.parse()?))), + ("ref.func", |p| Ok(RefFunc(p.parse()?))), + ] +}; + +impl<'a> Parse<'a> for WastRetCore<'a> { + fn parse(parser: Parser<'a>) -> Result { + let parse = parser.step(|c| { + if let Some((kw, rest)) = c.keyword() { + if let Some(i) = RETS.iter().position(|(name, _)| *name == kw) { + return Ok((RETS[i].1, rest)); + } + } + Err(c.error("expected a [type].const expression")) + })?; + parse(parser) + } +} + +impl Peek for WastRetCore<'_> { + fn peek(cursor: Cursor<'_>) -> bool { + let kw = match cursor.keyword() { + Some((kw, _)) => kw, + None => return false, + }; + RETS.iter().find(|(name, _)| *name == kw).is_some() + } + + fn display() -> &'static str { + "core wasm return value" + } +} + +/// Either a NaN pattern (`nan:canonical`, `nan:arithmetic`) or a value of type `T`. +#[derive(Debug, PartialEq)] +#[allow(missing_docs)] +pub enum NanPattern { + CanonicalNan, + ArithmeticNan, + Value(T), +} + +impl<'a, T> Parse<'a> for NanPattern +where + T: Parse<'a>, +{ + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::() { + parser.parse::()?; + Ok(NanPattern::CanonicalNan) + } else if parser.peek::() { + parser.parse::()?; + Ok(NanPattern::ArithmeticNan) + } else { + let val = parser.parse()?; + Ok(NanPattern::Value(val)) + } + } +} + +/// A version of `V128Const` that allows `NanPattern`s. +/// +/// This implementation is necessary because only float types can include NaN patterns; otherwise +/// it is largely similar to the implementation of `V128Const`. +#[derive(Debug)] +#[allow(missing_docs)] +pub enum V128Pattern { + I8x16([i8; 16]), + I16x8([i16; 8]), + I32x4([i32; 4]), + I64x2([i64; 2]), + F32x4([NanPattern; 4]), + F64x2([NanPattern; 2]), +} + +impl<'a> Parse<'a> for V128Pattern { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + parser.parse::()?; + Ok(V128Pattern::I8x16([ + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + ])) + } else if l.peek::() { + parser.parse::()?; + Ok(V128Pattern::I16x8([ + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + ])) + } else if l.peek::() { + parser.parse::()?; + Ok(V128Pattern::I32x4([ + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + ])) + } else if l.peek::() { + parser.parse::()?; + Ok(V128Pattern::I64x2([parser.parse()?, parser.parse()?])) + } else if l.peek::() { + parser.parse::()?; + Ok(V128Pattern::F32x4([ + parser.parse()?, + parser.parse()?, + parser.parse()?, + parser.parse()?, + ])) + } else if l.peek::() { + parser.parse::()?; + Ok(V128Pattern::F64x2([parser.parse()?, parser.parse()?])) + } else { + Err(l.error()) + } + } +} diff --git a/crates/wastlhw/src/encode.rs b/crates/wastlhw/src/encode.rs new file mode 100644 index 000000000..3fc932690 --- /dev/null +++ b/crates/wastlhw/src/encode.rs @@ -0,0 +1,75 @@ +pub(crate) trait Encode { + fn encode(&self, e: &mut Vec); +} + +impl Encode for &'_ T { + fn encode(&self, e: &mut Vec) { + T::encode(self, e) + } +} + +impl Encode for [T] { + fn encode(&self, e: &mut Vec) { + self.len().encode(e); + for item in self { + item.encode(e); + } + } +} + +impl Encode for Vec { + fn encode(&self, e: &mut Vec) { + <[T]>::encode(self, e) + } +} + +impl Encode for str { + fn encode(&self, e: &mut Vec) { + self.len().encode(e); + e.extend_from_slice(self.as_bytes()); + } +} + +impl Encode for usize { + fn encode(&self, e: &mut Vec) { + assert!(*self <= u32::max_value() as usize); + (*self as u32).encode(e) + } +} + +impl Encode for u8 { + fn encode(&self, e: &mut Vec) { + e.push(*self); + } +} + +impl Encode for u32 { + fn encode(&self, e: &mut Vec) { + leb128::write::unsigned(e, (*self).into()).unwrap(); + } +} + +impl Encode for i32 { + fn encode(&self, e: &mut Vec) { + leb128::write::signed(e, (*self).into()).unwrap(); + } +} + +impl Encode for u64 { + fn encode(&self, e: &mut Vec) { + leb128::write::unsigned(e, *self).unwrap(); + } +} + +impl Encode for i64 { + fn encode(&self, e: &mut Vec) { + leb128::write::signed(e, *self).unwrap(); + } +} + +impl Encode for (T, U) { + fn encode(&self, e: &mut Vec) { + self.0.encode(e); + self.1.encode(e); + } +} diff --git a/crates/wastlhw/src/error.rs b/crates/wastlhw/src/error.rs new file mode 100644 index 000000000..214e67833 --- /dev/null +++ b/crates/wastlhw/src/error.rs @@ -0,0 +1,196 @@ +use crate::lexer::LexError; +use crate::token::Span; +use std::fmt; +use std::path::{Path, PathBuf}; +use unicode_width::UnicodeWidthStr; + +/// A convenience error type to tie together all the detailed errors produced by +/// this crate. +/// +/// This type can be created from a [`LexError`]. This also contains +/// storage for file/text information so a nice error can be rendered along the +/// same lines of rustc's own error messages (minus the color). +/// +/// This type is typically suitable for use in public APIs for consumers of this +/// crate. +#[derive(Debug)] +pub struct Error { + inner: Box, +} + +#[derive(Debug)] +struct ErrorInner { + text: Option, + file: Option, + span: Span, + kind: ErrorKind, +} + +#[derive(Debug)] +struct Text { + line: usize, + col: usize, + snippet: String, +} + +#[derive(Debug)] +enum ErrorKind { + Lex(LexError), + Custom(String), +} + +impl Error { + pub(crate) fn lex(span: Span, content: &str, kind: LexError) -> Error { + let mut ret = Error { + inner: Box::new(ErrorInner { + text: None, + file: None, + span, + kind: ErrorKind::Lex(kind), + }), + }; + ret.set_text(content); + ret + } + + pub(crate) fn parse(span: Span, content: &str, message: String) -> Error { + let mut ret = Error { + inner: Box::new(ErrorInner { + text: None, + file: None, + span, + kind: ErrorKind::Custom(message), + }), + }; + ret.set_text(content); + ret + } + + /// Creates a new error with the given `message` which is targeted at the + /// given `span` + /// + /// Note that you'll want to ensure that `set_text` or `set_path` is called + /// on the resulting error to improve the rendering of the error message. + pub fn new(span: Span, message: String) -> Error { + Error { + inner: Box::new(ErrorInner { + text: None, + file: None, + span, + kind: ErrorKind::Custom(message), + }), + } + } + + /// Return the `Span` for this error. + pub fn span(&self) -> Span { + self.inner.span + } + + /// To provide a more useful error this function can be used to extract + /// relevant textual information about this error into the error itself. + /// + /// The `contents` here should be the full text of the original file being + /// parsed, and this will extract a sub-slice as necessary to render in the + /// `Display` implementation later on. + pub fn set_text(&mut self, contents: &str) { + if self.inner.text.is_some() { + return; + } + self.inner.text = Some(Text::new(contents, self.inner.span)); + } + + /// To provide a more useful error this function can be used to set + /// the file name that this error is associated with. + /// + /// The `path` here will be stored in this error and later rendered in the + /// `Display` implementation. + pub fn set_path(&mut self, path: &Path) { + if self.inner.file.is_some() { + return; + } + self.inner.file = Some(path.to_path_buf()); + } + + /// Returns the underlying `LexError`, if any, that describes this error. + pub fn lex_error(&self) -> Option<&LexError> { + match &self.inner.kind { + ErrorKind::Lex(e) => Some(e), + _ => None, + } + } + + /// Returns the underlying message, if any, that describes this error. + pub fn message(&self) -> String { + match &self.inner.kind { + ErrorKind::Lex(e) => e.to_string(), + ErrorKind::Custom(e) => e.clone(), + } + } +} + +impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let err = match &self.inner.kind { + ErrorKind::Lex(e) => e as &dyn fmt::Display, + ErrorKind::Custom(e) => e as &dyn fmt::Display, + }; + let text = match &self.inner.text { + Some(text) => text, + None => { + return write!(f, "{} at byte offset {}", err, self.inner.span.offset); + } + }; + let file = self + .inner + .file + .as_ref() + .and_then(|p| p.to_str()) + .unwrap_or(""); + write!( + f, + "\ +{err} + --> {file}:{line}:{col} + | + {line:4} | {text} + | {marker:>0$}", + text.col + 1, + file = file, + line = text.line + 1, + col = text.col + 1, + err = err, + text = text.snippet, + marker = "^", + ) + } +} + +impl std::error::Error for Error {} + +impl Text { + fn new(content: &str, span: Span) -> Text { + let (line, col) = span.linecol_in(content); + let contents = content.lines().nth(line).unwrap_or(""); + let mut snippet = String::new(); + for ch in contents.chars() { + match ch { + // Replace tabs with spaces to render consistently + '\t' => { + snippet.push_str(" "); + } + // these codepoints change how text is rendered so for clarity + // in error messages they're dropped. + '\u{202a}' | '\u{202b}' | '\u{202d}' | '\u{202e}' | '\u{2066}' | '\u{2067}' + | '\u{2068}' | '\u{206c}' | '\u{2069}' => {} + + c => snippet.push(c), + } + } + // Use the `unicode-width` crate to figure out how wide the snippet, up + // to our "column", actually is. That'll tell us how many spaces to + // place before the `^` character that points at the problem + let col = snippet.get(..col).map(|s| s.width()).unwrap_or(col); + Text { line, col, snippet } + } +} diff --git a/crates/wastlhw/src/gensym.rs b/crates/wastlhw/src/gensym.rs new file mode 100644 index 000000000..9f718f06d --- /dev/null +++ b/crates/wastlhw/src/gensym.rs @@ -0,0 +1,20 @@ +use crate::token::{Id, Span}; +use std::cell::Cell; + +thread_local!(static NEXT: Cell = Cell::new(0)); + +pub fn reset() { + NEXT.with(|c| c.set(0)); +} + +pub fn gen(span: Span) -> Id<'static> { + NEXT.with(|next| { + let gen = next.get() + 1; + next.set(gen); + Id::gensym(span, gen) + }) +} + +pub fn fill<'a>(span: Span, slot: &mut Option>) -> Id<'a> { + *slot.get_or_insert_with(|| gen(span)) +} diff --git a/crates/wastlhw/src/lexer.rs b/crates/wastlhw/src/lexer.rs new file mode 100644 index 000000000..2a08119bc --- /dev/null +++ b/crates/wastlhw/src/lexer.rs @@ -0,0 +1,1267 @@ +//! Definition of a lexer for the WebAssembly text format. +//! +//! This module provides a [`Lexer`][] type which is an iterate over the raw +//! tokens of a WebAssembly text file. A [`Lexer`][] accounts for every single +//! byte in a WebAssembly text field, returning tokens even for comments and +//! whitespace. Typically you'll ignore comments and whitespace, however. +//! +//! If you'd like to iterate over the tokens in a file you can do so via: +//! +//! ``` +//! # fn foo() -> Result<(), wast::Error> { +//! use wast::lexer::Lexer; +//! +//! let wat = "(module (func $foo))"; +//! for token in Lexer::new(wat) { +//! println!("{:?}", token?); +//! } +//! # Ok(()) +//! # } +//! ``` +//! +//! Note that you'll typically not use this module but will rather use +//! [`ParseBuffer`](crate::parser::ParseBuffer) instead. +//! +//! [`Lexer`]: crate::lexer::Lexer + +use crate::token::Span; +use crate::Error; +use std::borrow::Cow; +use std::char; +use std::fmt; +use std::str; + +/// A structure used to lex the s-expression syntax of WAT files. +/// +/// This structure is used to generate [`Token`] items, which should account for +/// every single byte of the input as we iterate over it. A [`LexError`] is +/// returned for any non-lexable text. +#[derive(Clone)] +pub struct Lexer<'a> { + remaining: &'a str, + input: &'a str, + allow_confusing_unicode: bool, +} + +/// A fragment of source lex'd from an input string. +/// +/// This enumeration contains all kinds of fragments, including comments and +/// whitespace. For most cases you'll probably ignore these and simply look at +/// tokens. +#[derive(Debug, PartialEq)] +pub enum Token<'a> { + /// A line comment, preceded with `;;` + LineComment(&'a str), + + /// A block comment, surrounded by `(;` and `;)`. Note that these can be + /// nested. + BlockComment(&'a str), + + /// A fragment of source that represents whitespace. + Whitespace(&'a str), + + /// A left-parenthesis, including the source text for where it comes from. + LParen(&'a str), + /// A right-parenthesis, including the source text for where it comes from. + RParen(&'a str), + + /// A string literal, which is actually a list of bytes. + String(WasmString<'a>), + + /// An identifier (like `$foo`). + /// + /// All identifiers start with `$` and the payload here is the original + /// source text. + Id(&'a str), + + /// A keyword, or something that starts with an alphabetic character. + /// + /// The payload here is the original source text. + Keyword(&'a str), + + /// A reserved series of `idchar` symbols. Unknown what this is meant to be + /// used for, you'll probably generate an error about an unexpected token. + Reserved(&'a str), + + /// An integer. + Integer(Integer<'a>), + + /// A float. + Float(Float<'a>), +} + +/// Errors that can be generated while lexing. +/// +/// All lexing errors have line/colum/position information as well as a +/// `LexError` indicating what kind of error happened while lexing. +#[derive(Debug, Clone, PartialEq)] +#[non_exhaustive] +pub enum LexError { + /// A dangling block comment was found with an unbalanced `(;` which was + /// never terminated in the file. + DanglingBlockComment, + + /// An unexpected character was encountered when generally parsing and + /// looking for something else. + Unexpected(char), + + /// An invalid `char` in a string literal was found. + InvalidStringElement(char), + + /// An invalid string escape letter was found (the thing after the `\` in + /// string literals) + InvalidStringEscape(char), + + /// An invalid hexadecimal digit was found. + InvalidHexDigit(char), + + /// An invalid base-10 digit was found. + InvalidDigit(char), + + /// Parsing expected `wanted` but ended up finding `found` instead where the + /// two characters aren't the same. + Expected { + /// The character that was expected to be found + wanted: char, + /// The character that was actually found + found: char, + }, + + /// We needed to parse more but EOF (or end of the string) was encountered. + UnexpectedEof, + + /// A number failed to parse because it was too big to fit within the target + /// type. + NumberTooBig, + + /// An invalid unicode value was found in a `\u{...}` escape in a string, + /// only valid unicode scalars can be escaped that way. + InvalidUnicodeValue(u32), + + /// A lone underscore was found when parsing a number, since underscores + /// should always be preceded and succeeded with a digit of some form. + LoneUnderscore, + + /// A "confusing" unicode character is present in a comment or a string + /// literal, such as a character that changes the direction text is + /// typically displayed in editors. This could cause the human-read + /// version to behave differently than the compiler-visible version, so + /// these are simply rejected for now. + ConfusingUnicode(char), +} + +/// A sign token for an integer. +#[derive(Clone, Copy, Debug, PartialEq)] +pub enum SignToken { + /// Plus sign: "+", + Plus, + /// Minus sign: "-", + Minus, +} + +/// A parsed integer, signed or unsigned. +/// +/// Methods can be use to access the value of the integer. +#[derive(Debug, PartialEq)] +pub struct Integer<'a>(Box>); + +#[derive(Debug, PartialEq)] +struct IntegerInner<'a> { + sign: Option, + src: &'a str, + val: Cow<'a, str>, + hex: bool, +} + +/// A parsed float. +/// +/// Methods can be use to access the value of the float. +#[derive(Debug, PartialEq)] +pub struct Float<'a>(Box>); + +#[derive(Debug, PartialEq)] +struct FloatInner<'a> { + src: &'a str, + val: FloatVal<'a>, +} + +/// A parsed string. +#[derive(Debug, PartialEq)] +pub struct WasmString<'a>(Box>); + +#[derive(Debug, PartialEq)] +struct WasmStringInner<'a> { + src: &'a str, + val: Cow<'a, [u8]>, +} + +/// Possible parsed float values +#[derive(Debug, PartialEq)] +pub enum FloatVal<'a> { + /// A float `NaN` representation + Nan { + /// The specific bits to encode for this float, optionally + val: Option, + /// Whether or not this is a negative `NaN` or not. + negative: bool, + }, + /// An float infinite representation, + Inf { + #[allow(missing_docs)] + negative: bool, + }, + /// A parsed and separated floating point value + Val { + /// Whether or not the `integral` and `decimal` are specified in hex + hex: bool, + /// The float parts before the `.` + integral: Cow<'a, str>, + /// The float parts after the `.` + decimal: Option>, + /// The exponent to multiple this `integral.decimal` portion of the + /// float by. If `hex` is true this is `2^exponent` and otherwise it's + /// `10^exponent` + exponent: Option>, + }, +} + +// https://webassembly.github.io/spec/core/text/values.html#text-idchar +macro_rules! idchars { + () => { + b'0'..=b'9' + | b'A'..=b'Z' + | b'a'..=b'z' + | b'!' + | b'#' + | b'$' + | b'%' + | b'&' + | b'\'' + | b'*' + | b'+' + | b'-' + | b'.' + | b'/' + | b':' + | b'<' + | b'=' + | b'>' + | b'?' + | b'@' + | b'\\' + | b'^' + | b'_' + | b'`' + | b'|' + | b'~' + } +} + +impl<'a> Lexer<'a> { + /// Creates a new lexer which will lex the `input` source string. + pub fn new(input: &str) -> Lexer<'_> { + Lexer { + remaining: input, + input, + allow_confusing_unicode: false, + } + } + + /// Returns the original source input that we're lexing. + pub fn input(&self) -> &'a str { + self.input + } + + /// Configures whether "confusing" unicode characters are allowed while + /// lexing. + /// + /// If allowed then no error will happen if these characters are found, but + /// otherwise if disallowed a lex error will be produced when these + /// characters are found. Confusing characters are denied by default. + /// + /// For now "confusing characters" are primarily related to the "trojan + /// source" problem where it refers to characters which cause humans to read + /// text differently than this lexer, such as characters that alter the + /// left-to-right display of the source code. + pub fn allow_confusing_unicode(&mut self, allow: bool) -> &mut Self { + self.allow_confusing_unicode = allow; + self + } + + /// Lexes the next token in the input. + /// + /// Returns `Some` if a token is found or `None` if we're at EOF. + /// + /// # Errors + /// + /// Returns an error if the input is malformed. + pub fn parse(&mut self) -> Result>, Error> { + let pos = self.cur(); + // This `match` generally parses the grammar specified at + // + // https://webassembly.github.io/spec/core/text/lexical.html#text-token + let byte = match self.remaining.as_bytes().get(0) { + Some(b) => b, + None => return Ok(None), + }; + + match byte { + // Open-parens check the next character to see if this is the start + // of a block comment, otherwise it's just a bland left-paren + // token. + b'(' => match self.remaining.as_bytes().get(1) { + Some(b';') => { + let mut level = 1; + // Note that we're doing a byte-level search here for the + // close-delimiter of `;)`. The actual source text is utf-8 + // encode in `self.remaining` but due to how utf-8 works we + // can safely search for an ASCII byte since it'll never + // otherwise appear in the middle of a codepoint and if we + // find it then it's guaranteed to be the right byte. + // + // Mainly we're avoiding the overhead of decoding utf-8 + // characters into a Rust `char` since it's otherwise + // unnecessary work. + let mut iter = self.remaining.as_bytes()[2..].iter(); + while let Some(ch) = iter.next() { + match ch { + b'(' => { + if let Some(b';') = iter.as_slice().get(0) { + level += 1; + iter.next(); + } + } + b';' => { + if let Some(b')') = iter.as_slice().get(0) { + level -= 1; + iter.next(); + if level == 0 { + let len = self.remaining.len() - iter.as_slice().len(); + let (comment, remaining) = self.remaining.split_at(len); + self.remaining = remaining; + self.check_confusing_comment(comment)?; + return Ok(Some(Token::BlockComment(comment))); + } + } + } + _ => {} + } + } + Err(self.error(pos, LexError::DanglingBlockComment)) + } + _ => Ok(Some(Token::LParen(self.split_first_byte()))), + }, + + b')' => Ok(Some(Token::RParen(self.split_first_byte()))), + + b'"' => { + let val = self.string()?; + let src = &self.input[pos..self.cur()]; + return Ok(Some(Token::String(WasmString(Box::new(WasmStringInner { + val, + src, + }))))); + } + + // https://webassembly.github.io/spec/core/text/lexical.html#white-space + b' ' | b'\n' | b'\r' | b'\t' => Ok(Some(Token::Whitespace(self.split_ws()))), + + c @ idchars!() => { + let reserved = self.split_while(|b| match b { + idchars!() => true, + _ => false, + }); + + // https://webassembly.github.io/spec/core/text/values.html#integers + if let Some(number) = self.number(reserved) { + Ok(Some(number)) + // https://webassembly.github.io/spec/core/text/values.html#text-id + } else if *c == b'$' && reserved.len() > 1 { + Ok(Some(Token::Id(reserved))) + // https://webassembly.github.io/spec/core/text/lexical.html#text-keyword + } else if b'a' <= *c && *c <= b'z' { + Ok(Some(Token::Keyword(reserved))) + } else { + Ok(Some(Token::Reserved(reserved))) + } + } + + // This could be a line comment, otherwise `;` is a reserved token. + // The second byte is checked to see if it's a `;;` line comment + b';' => match self.remaining.as_bytes().get(1) { + Some(b';') => { + let comment = self.split_until(b'\n'); + self.check_confusing_comment(comment)?; + Ok(Some(Token::LineComment(comment))) + } + _ => Ok(Some(Token::Reserved(self.split_first_byte()))), + }, + + // Other known reserved tokens other than `;` + b',' | b'[' | b']' | b'{' | b'}' => Ok(Some(Token::Reserved(self.split_first_byte()))), + + _ => { + let ch = self.remaining.chars().next().unwrap(); + Err(self.error(pos, LexError::Unexpected(ch))) + } + } + } + + fn split_first_byte(&mut self) -> &'a str { + let (token, remaining) = self.remaining.split_at(1); + self.remaining = remaining; + token + } + + fn split_until(&mut self, byte: u8) -> &'a str { + let pos = memchr::memchr(byte, self.remaining.as_bytes()).unwrap_or(self.remaining.len()); + let (ret, remaining) = self.remaining.split_at(pos); + self.remaining = remaining; + ret + } + + fn split_ws(&mut self) -> &'a str { + // This table is a byte lookup table to determine whether a byte is a + // whitespace byte. There are only 4 whitespace bytes for the `*.wat` + // format right now which are ' ', '\t', '\r', and '\n'. These 4 bytes + // have a '1' in the table below. + // + // Due to how utf-8 works (our input is guaranteed to be utf-8) it is + // known that if these bytes are found they're guaranteed to be the + // whitespace byte, so they can be safely skipped and we don't have to + // do full utf-8 decoding. This means that the goal of this function is + // to find the first non-whitespace byte in `self.remaining`. + // + // For now this lookup table seems to be the fastest, but projects like + // https://github.com/lemire/despacer show other simd algorithms which + // can possibly accelerate this even more. Note that `*.wat` files often + // have a lot of whitespace so this function is typically quite hot when + // parsing inputs. + #[rustfmt::skip] + const WS: [u8; 256] = [ + // \t \n \r + /* 0x00 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, + /* 0x10 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + // ' ' + /* 0x20 */ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0x30 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0x40 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0x50 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0x60 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0x70 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0x80 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0x90 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0xa0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0xb0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0xc0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0xd0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0xe0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + /* 0xf0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ]; + let pos = self + .remaining + .as_bytes() + .iter() + .position(|b| WS[*b as usize] != 1) + .unwrap_or(self.remaining.len()); + let (ret, remaining) = self.remaining.split_at(pos); + self.remaining = remaining; + ret + } + + fn split_while(&mut self, f: impl Fn(u8) -> bool) -> &'a str { + let pos = self + .remaining + .as_bytes() + .iter() + .position(|b| !f(*b)) + .unwrap_or(self.remaining.len()); + let (ret, remaining) = self.remaining.split_at(pos); + self.remaining = remaining; + ret + } + + fn number(&self, src: &'a str) -> Option> { + let (sign, num) = if let Some(stripped) = src.strip_prefix('+') { + (Some(SignToken::Plus), stripped) + } else if let Some(stripped) = src.strip_prefix('-') { + (Some(SignToken::Minus), stripped) + } else { + (None, src) + }; + + let negative = sign == Some(SignToken::Minus); + + // Handle `inf` and `nan` which are special numbers here + if num == "inf" { + return Some(Token::Float(Float(Box::new(FloatInner { + src, + val: FloatVal::Inf { negative }, + })))); + } else if num == "nan" { + return Some(Token::Float(Float(Box::new(FloatInner { + src, + val: FloatVal::Nan { + val: None, + negative, + }, + })))); + } else if let Some(stripped) = num.strip_prefix("nan:0x") { + let mut it = stripped.chars(); + let to_parse = skip_undescores(&mut it, false, char::is_ascii_hexdigit)?; + if it.next().is_some() { + return None; + } + let n = u64::from_str_radix(&to_parse, 16).ok()?; + return Some(Token::Float(Float(Box::new(FloatInner { + src, + val: FloatVal::Nan { + val: Some(n), + negative, + }, + })))); + } + + // Figure out if we're a hex number or not + let (mut it, hex, test_valid) = if let Some(stripped) = num.strip_prefix("0x") { + ( + stripped.chars(), + true, + char::is_ascii_hexdigit as fn(&char) -> bool, + ) + } else { + ( + num.chars(), + false, + char::is_ascii_digit as fn(&char) -> bool, + ) + }; + + // Evaluate the first part, moving out all underscores + let val = skip_undescores(&mut it, negative, test_valid)?; + + match it.clone().next() { + // If we're followed by something this may be a float so keep going. + Some(_) => {} + + // Otherwise this is a valid integer literal! + None => { + return Some(Token::Integer(Integer(Box::new(IntegerInner { + sign, + src, + val, + hex, + })))) + } + } + + // A number can optionally be after the decimal so only actually try to + // parse one if it's there. + let decimal = if it.clone().next() == Some('.') { + it.next(); + match it.clone().next() { + Some(c) if test_valid(&c) => Some(skip_undescores(&mut it, false, test_valid)?), + Some(_) | None => None, + } + } else { + None + }; + + // Figure out if there's an exponential part here to make a float, and + // if so parse it but defer its actual calculation until later. + let exponent = match (hex, it.next()) { + (true, Some('p')) | (true, Some('P')) | (false, Some('e')) | (false, Some('E')) => { + let negative = match it.clone().next() { + Some('-') => { + it.next(); + true + } + Some('+') => { + it.next(); + false + } + _ => false, + }; + Some(skip_undescores(&mut it, negative, char::is_ascii_digit)?) + } + (_, None) => None, + _ => return None, + }; + + // We should have eaten everything by now, if not then this is surely + // not a float or integer literal. + if it.next().is_some() { + return None; + } + + return Some(Token::Float(Float(Box::new(FloatInner { + src, + val: FloatVal::Val { + hex, + integral: val, + exponent, + decimal, + }, + })))); + + fn skip_undescores<'a>( + it: &mut str::Chars<'a>, + negative: bool, + good: fn(&char) -> bool, + ) -> Option> { + enum State { + Raw, + Collecting(String), + } + let mut last_underscore = false; + let mut state = if negative { + State::Collecting("-".to_string()) + } else { + State::Raw + }; + let input = it.as_str(); + let first = it.next()?; + if !good(&first) { + return None; + } + if let State::Collecting(s) = &mut state { + s.push(first); + } + let mut last = 1; + while let Some(c) = it.clone().next() { + if c == '_' && !last_underscore { + if let State::Raw = state { + state = State::Collecting(input[..last].to_string()); + } + it.next(); + last_underscore = true; + continue; + } + if !good(&c) { + break; + } + if let State::Collecting(s) = &mut state { + s.push(c); + } + last_underscore = false; + it.next(); + last += 1; + } + if last_underscore { + return None; + } + Some(match state { + State::Raw => input[..last].into(), + State::Collecting(s) => s.into(), + }) + } + } + + /// Verifies that `comment`, which is about to be returned, has a "confusing + /// unicode character" in it and should instead be transformed into an + /// error. + fn check_confusing_comment(&self, comment: &str) -> Result<(), Error> { + if self.allow_confusing_unicode { + return Ok(()); + } + + // In an effort to avoid utf-8 decoding the entire `comment` the search + // here is a bit more optimized. This checks for the `0xe2` byte because + // in the utf-8 encoding that's the leading encoding byte for all + // "confusing characters". Each instance of 0xe2 is checked to see if it + // starts a confusing character, and if so that's returned. + // + // Also note that 0xe2 will never be found in the middle of a codepoint, + // it's always the start of a codepoint. This means that if our special + // characters show up they're guaranteed to start with 0xe2 bytes. + let bytes = comment.as_bytes(); + for pos in memchr::Memchr::new(0xe2, bytes) { + if let Some(c) = comment[pos..].chars().next() { + if is_confusing_unicode(c) { + // Note that `self.cur()` accounts for already having + // parsed `comment`, so we move backwards to where + // `comment` started and then add the index within + // `comment`. + let pos = self.cur() - comment.len() + pos; + return Err(self.error(pos, LexError::ConfusingUnicode(c))); + } + } + } + + Ok(()) + } + + /// Reads everything for a literal string except the leading `"`. Returns + /// the string value that has been read. + /// + /// https://webassembly.github.io/spec/core/text/values.html#text-string + fn string(&mut self) -> Result, Error> { + let mut it = self.remaining[1..].chars(); + let result = Lexer::parse_str(&mut it, self.allow_confusing_unicode); + let end = self.input.len() - it.as_str().len(); + self.remaining = &self.input[end..]; + result.map_err(|e| { + let err_pos = match &e { + LexError::UnexpectedEof => self.input.len(), + _ => self.input[..end].char_indices().next_back().unwrap().0, + }; + self.error(err_pos, e) + }) + } + + fn parse_str( + it: &mut str::Chars<'a>, + allow_confusing_unicode: bool, + ) -> Result, LexError> { + enum State { + Start, + String(Vec), + } + let orig = it.as_str(); + let mut state = State::Start; + loop { + match it.next().ok_or(LexError::UnexpectedEof)? { + '"' => break, + '\\' => { + match state { + State::String(_) => {} + State::Start => { + let pos = orig.len() - it.as_str().len() - 1; + state = State::String(orig[..pos].as_bytes().to_vec()); + } + } + let buf = match &mut state { + State::String(b) => b, + State::Start => unreachable!(), + }; + match it.next().ok_or(LexError::UnexpectedEof)? { + '"' => buf.push(b'"'), + '\'' => buf.push(b'\''), + 't' => buf.push(b'\t'), + 'n' => buf.push(b'\n'), + 'r' => buf.push(b'\r'), + '\\' => buf.push(b'\\'), + 'u' => { + Lexer::must_eat_char(it, '{')?; + let n = Lexer::hexnum(it)?; + let c = char::from_u32(n).ok_or(LexError::InvalidUnicodeValue(n))?; + buf.extend(c.encode_utf8(&mut [0; 4]).as_bytes()); + Lexer::must_eat_char(it, '}')?; + } + c1 if c1.is_ascii_hexdigit() => { + let c2 = Lexer::hexdigit(it)?; + buf.push(to_hex(c1) * 16 + c2); + } + c => return Err(LexError::InvalidStringEscape(c)), + } + } + c if (c as u32) < 0x20 || c as u32 == 0x7f => { + return Err(LexError::InvalidStringElement(c)) + } + c if !allow_confusing_unicode && is_confusing_unicode(c) => { + return Err(LexError::ConfusingUnicode(c)) + } + c => match &mut state { + State::Start => {} + State::String(v) => { + v.extend(c.encode_utf8(&mut [0; 4]).as_bytes()); + } + }, + } + } + match state { + State::Start => Ok(orig[..orig.len() - it.as_str().len() - 1].as_bytes().into()), + State::String(s) => Ok(s.into()), + } + } + + fn hexnum(it: &mut str::Chars<'_>) -> Result { + let n = Lexer::hexdigit(it)?; + let mut last_underscore = false; + let mut n = n as u32; + while let Some(c) = it.clone().next() { + if c == '_' { + it.next(); + last_underscore = true; + continue; + } + if !c.is_ascii_hexdigit() { + break; + } + last_underscore = false; + it.next(); + n = n + .checked_mul(16) + .and_then(|n| n.checked_add(to_hex(c) as u32)) + .ok_or(LexError::NumberTooBig)?; + } + if last_underscore { + return Err(LexError::LoneUnderscore); + } + Ok(n) + } + + /// Reads a hexidecimal digit from the input stream, returning where it's + /// defined and the hex value. Returns an error on EOF or an invalid hex + /// digit. + fn hexdigit(it: &mut str::Chars<'_>) -> Result { + let ch = Lexer::must_char(it)?; + if ch.is_ascii_hexdigit() { + Ok(to_hex(ch)) + } else { + Err(LexError::InvalidHexDigit(ch)) + } + } + + /// Reads the next character from the input string and where it's located, + /// returning an error if the input stream is empty. + fn must_char(it: &mut str::Chars<'_>) -> Result { + it.next().ok_or(LexError::UnexpectedEof) + } + + /// Expects that a specific character must be read next + fn must_eat_char(it: &mut str::Chars<'_>, wanted: char) -> Result<(), LexError> { + let found = Lexer::must_char(it)?; + if wanted == found { + Ok(()) + } else { + Err(LexError::Expected { wanted, found }) + } + } + + /// Returns the current position of our iterator through the input string + fn cur(&self) -> usize { + self.input.len() - self.remaining.len() + } + + /// Creates an error at `pos` with the specified `kind` + fn error(&self, pos: usize, kind: LexError) -> Error { + Error::lex(Span { offset: pos }, self.input, kind) + } +} + +impl<'a> Iterator for Lexer<'a> { + type Item = Result, Error>; + + fn next(&mut self) -> Option { + self.parse().transpose() + } +} + +impl<'a> Token<'a> { + /// Returns the original source text for this token. + pub fn src(&self) -> &'a str { + match self { + Token::Whitespace(s) => s, + Token::BlockComment(s) => s, + Token::LineComment(s) => s, + Token::LParen(s) => s, + Token::RParen(s) => s, + Token::String(s) => s.src(), + Token::Id(s) => s, + Token::Keyword(s) => s, + Token::Reserved(s) => s, + Token::Integer(i) => i.src(), + Token::Float(f) => f.src(), + } + } +} + +impl<'a> Integer<'a> { + /// Returns the sign token for this integer. + pub fn sign(&self) -> Option { + self.0.sign + } + + /// Returns the original source text for this integer. + pub fn src(&self) -> &'a str { + self.0.src + } + + /// Returns the value string that can be parsed for this integer, as well as + /// the base that it should be parsed in + pub fn val(&self) -> (&str, u32) { + (&self.0.val, if self.0.hex { 16 } else { 10 }) + } +} + +impl<'a> Float<'a> { + /// Returns the original source text for this integer. + pub fn src(&self) -> &'a str { + self.0.src + } + + /// Returns a parsed value of this float with all of the components still + /// listed as strings. + pub fn val(&self) -> &FloatVal<'a> { + &self.0.val + } +} + +impl<'a> WasmString<'a> { + /// Returns the original source text for this string. + pub fn src(&self) -> &'a str { + self.0.src + } + + /// Returns a parsed value, as a list of bytes, for this string. + pub fn val(&self) -> &[u8] { + &self.0.val + } +} + +fn to_hex(c: char) -> u8 { + match c { + 'a'..='f' => c as u8 - b'a' + 10, + 'A'..='F' => c as u8 - b'A' + 10, + _ => c as u8 - b'0', + } +} + +impl fmt::Display for LexError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + use LexError::*; + match self { + DanglingBlockComment => f.write_str("unterminated block comment")?, + Unexpected(c) => write!(f, "unexpected character '{}'", escape_char(*c))?, + InvalidStringElement(c) => { + write!(f, "invalid character in string '{}'", escape_char(*c))? + } + InvalidStringEscape(c) => write!(f, "invalid string escape '{}'", escape_char(*c))?, + InvalidHexDigit(c) => write!(f, "invalid hex digit '{}'", escape_char(*c))?, + InvalidDigit(c) => write!(f, "invalid decimal digit '{}'", escape_char(*c))?, + Expected { wanted, found } => write!( + f, + "expected '{}' but found '{}'", + escape_char(*wanted), + escape_char(*found) + )?, + UnexpectedEof => write!(f, "unexpected end-of-file")?, + NumberTooBig => f.write_str("number is too big to parse")?, + InvalidUnicodeValue(c) => write!(f, "invalid unicode scalar value 0x{:x}", c)?, + LoneUnderscore => write!(f, "bare underscore in numeric literal")?, + ConfusingUnicode(c) => write!(f, "likely-confusing unicode character found {:?}", c)?, + } + Ok(()) + } +} + +fn escape_char(c: char) -> String { + match c { + '\t' => String::from("\\t"), + '\r' => String::from("\\r"), + '\n' => String::from("\\n"), + '\\' => String::from("\\\\"), + '\'' => String::from("\\\'"), + '\"' => String::from("\""), + '\x20'..='\x7e' => String::from(c), + _ => c.escape_unicode().to_string(), + } +} + +/// This is an attempt to protect agains the "trojan source" [1] problem where +/// unicode characters can cause editors to render source code differently +/// for humans than the compiler itself sees. +/// +/// To mitigate this issue, and because it's relatively rare in practice, +/// this simply rejects characters of that form. +/// +/// [1]: https://www.trojansource.codes/ +fn is_confusing_unicode(ch: char) -> bool { + match ch { + '\u{202a}' | '\u{202b}' | '\u{202d}' | '\u{202e}' | '\u{2066}' | '\u{2067}' + | '\u{2068}' | '\u{206c}' | '\u{2069}' => true, + _ => false, + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn ws_smoke() { + fn get_whitespace(input: &str) -> &str { + match Lexer::new(input).parse().expect("no first token") { + Some(Token::Whitespace(s)) => s, + other => panic!("unexpected {:?}", other), + } + } + assert_eq!(get_whitespace(" "), " "); + assert_eq!(get_whitespace(" "), " "); + assert_eq!(get_whitespace(" \n "), " \n "); + assert_eq!(get_whitespace(" x"), " "); + assert_eq!(get_whitespace(" ;"), " "); + } + + #[test] + fn line_comment_smoke() { + fn get_line_comment(input: &str) -> &str { + match Lexer::new(input).parse().expect("no first token") { + Some(Token::LineComment(s)) => s, + other => panic!("unexpected {:?}", other), + } + } + assert_eq!(get_line_comment(";;"), ";;"); + assert_eq!(get_line_comment(";; xyz"), ";; xyz"); + assert_eq!(get_line_comment(";; xyz\nabc"), ";; xyz"); + assert_eq!(get_line_comment(";;\nabc"), ";;"); + assert_eq!(get_line_comment(";; \nabc"), ";; "); + } + + #[test] + fn block_comment_smoke() { + fn get_block_comment(input: &str) -> &str { + match Lexer::new(input).parse().expect("no first token") { + Some(Token::BlockComment(s)) => s, + other => panic!("unexpected {:?}", other), + } + } + assert_eq!(get_block_comment("(;;)"), "(;;)"); + assert_eq!(get_block_comment("(; ;)"), "(; ;)"); + assert_eq!(get_block_comment("(; (;;) ;)"), "(; (;;) ;)"); + } + + fn get_token(input: &str) -> Token<'_> { + Lexer::new(input) + .parse() + .expect("no first token") + .expect("no token") + } + + #[test] + fn lparen() { + assert_eq!(get_token("(("), Token::LParen("(")); + } + + #[test] + fn rparen() { + assert_eq!(get_token(")("), Token::RParen(")")); + } + + #[test] + fn strings() { + fn get_string(input: &str) -> Vec { + match get_token(input) { + Token::String(s) => { + assert_eq!(input, s.src()); + s.val().to_vec() + } + other => panic!("not string {:?}", other), + } + } + assert_eq!(&*get_string("\"\""), b""); + assert_eq!(&*get_string("\"a\""), b"a"); + assert_eq!(&*get_string("\"a b c d\""), b"a b c d"); + assert_eq!(&*get_string("\"\\\"\""), b"\""); + assert_eq!(&*get_string("\"\\'\""), b"'"); + assert_eq!(&*get_string("\"\\n\""), b"\n"); + assert_eq!(&*get_string("\"\\t\""), b"\t"); + assert_eq!(&*get_string("\"\\r\""), b"\r"); + assert_eq!(&*get_string("\"\\\\\""), b"\\"); + assert_eq!(&*get_string("\"\\01\""), &[1]); + assert_eq!(&*get_string("\"\\u{1}\""), &[1]); + assert_eq!( + &*get_string("\"\\u{0f3}\""), + '\u{0f3}'.encode_utf8(&mut [0; 4]).as_bytes() + ); + assert_eq!( + &*get_string("\"\\u{0_f_3}\""), + '\u{0f3}'.encode_utf8(&mut [0; 4]).as_bytes() + ); + + for i in 0..=255i32 { + let s = format!("\"\\{:02x}\"", i); + assert_eq!(&*get_string(&s), &[i as u8]); + } + } + + #[test] + fn id() { + fn get_id(input: &str) -> &str { + match get_token(input) { + Token::Id(s) => s, + other => panic!("not id {:?}", other), + } + } + assert_eq!(get_id("$x"), "$x"); + assert_eq!(get_id("$xyz"), "$xyz"); + assert_eq!(get_id("$x_z"), "$x_z"); + assert_eq!(get_id("$0^"), "$0^"); + assert_eq!(get_id("$0^;;"), "$0^"); + assert_eq!(get_id("$0^ ;;"), "$0^"); + } + + #[test] + fn keyword() { + fn get_keyword(input: &str) -> &str { + match get_token(input) { + Token::Keyword(s) => s, + other => panic!("not id {:?}", other), + } + } + assert_eq!(get_keyword("x"), "x"); + assert_eq!(get_keyword("xyz"), "xyz"); + assert_eq!(get_keyword("x_z"), "x_z"); + assert_eq!(get_keyword("x_z "), "x_z"); + assert_eq!(get_keyword("x_z "), "x_z"); + } + + #[test] + fn reserved() { + fn get_reserved(input: &str) -> &str { + match get_token(input) { + Token::Reserved(s) => s, + other => panic!("not reserved {:?}", other), + } + } + assert_eq!(get_reserved("$ "), "$"); + assert_eq!(get_reserved("^_x "), "^_x"); + } + + #[test] + fn integer() { + fn get_integer(input: &str) -> String { + match get_token(input) { + Token::Integer(i) => { + assert_eq!(input, i.src()); + i.val().0.to_string() + } + other => panic!("not integer {:?}", other), + } + } + assert_eq!(get_integer("1"), "1"); + assert_eq!(get_integer("0"), "0"); + assert_eq!(get_integer("-1"), "-1"); + assert_eq!(get_integer("+1"), "1"); + assert_eq!(get_integer("+1_000"), "1000"); + assert_eq!(get_integer("+1_0_0_0"), "1000"); + assert_eq!(get_integer("+0x10"), "10"); + assert_eq!(get_integer("-0x10"), "-10"); + assert_eq!(get_integer("0x10"), "10"); + } + + #[test] + fn float() { + fn get_float(input: &str) -> FloatVal<'_> { + match get_token(input) { + Token::Float(i) => { + assert_eq!(input, i.src()); + i.0.val + } + other => panic!("not reserved {:?}", other), + } + } + assert_eq!( + get_float("nan"), + FloatVal::Nan { + val: None, + negative: false + }, + ); + assert_eq!( + get_float("-nan"), + FloatVal::Nan { + val: None, + negative: true, + }, + ); + assert_eq!( + get_float("+nan"), + FloatVal::Nan { + val: None, + negative: false, + }, + ); + assert_eq!( + get_float("+nan:0x1"), + FloatVal::Nan { + val: Some(1), + negative: false, + }, + ); + assert_eq!( + get_float("nan:0x7f_ffff"), + FloatVal::Nan { + val: Some(0x7fffff), + negative: false, + }, + ); + assert_eq!(get_float("inf"), FloatVal::Inf { negative: false }); + assert_eq!(get_float("-inf"), FloatVal::Inf { negative: true }); + assert_eq!(get_float("+inf"), FloatVal::Inf { negative: false }); + + assert_eq!( + get_float("1.2"), + FloatVal::Val { + integral: "1".into(), + decimal: Some("2".into()), + exponent: None, + hex: false, + }, + ); + assert_eq!( + get_float("1.2e3"), + FloatVal::Val { + integral: "1".into(), + decimal: Some("2".into()), + exponent: Some("3".into()), + hex: false, + }, + ); + assert_eq!( + get_float("-1_2.1_1E+0_1"), + FloatVal::Val { + integral: "-12".into(), + decimal: Some("11".into()), + exponent: Some("01".into()), + hex: false, + }, + ); + assert_eq!( + get_float("+1_2.1_1E-0_1"), + FloatVal::Val { + integral: "12".into(), + decimal: Some("11".into()), + exponent: Some("-01".into()), + hex: false, + }, + ); + assert_eq!( + get_float("0x1_2.3_4p5_6"), + FloatVal::Val { + integral: "12".into(), + decimal: Some("34".into()), + exponent: Some("56".into()), + hex: true, + }, + ); + assert_eq!( + get_float("+0x1_2.3_4P-5_6"), + FloatVal::Val { + integral: "12".into(), + decimal: Some("34".into()), + exponent: Some("-56".into()), + hex: true, + }, + ); + assert_eq!( + get_float("1."), + FloatVal::Val { + integral: "1".into(), + decimal: None, + exponent: None, + hex: false, + }, + ); + assert_eq!( + get_float("0x1p-24"), + FloatVal::Val { + integral: "1".into(), + decimal: None, + exponent: Some("-24".into()), + hex: true, + }, + ); + } +} diff --git a/crates/wastlhw/src/lib.rs b/crates/wastlhw/src/lib.rs new file mode 100644 index 000000000..3d301cca5 --- /dev/null +++ b/crates/wastlhw/src/lib.rs @@ -0,0 +1,513 @@ +//! A crate for low-level parsing of the WebAssembly text formats: WAT and WAST. +//! +//! This crate is intended to be a low-level detail of the `wat` crate, +//! providing a low-level parsing API for parsing WebAssembly text format +//! structures. The API provided by this crate is very similar to +//! [`syn`](https://docs.rs/syn) and provides the ability to write customized +//! parsers which may be an extension to the core WebAssembly text format. For +//! more documentation see the [`parser`] module. +//! +//! # High-level Overview +//! +//! This crate provides a few major pieces of functionality +//! +//! * [`lexer`] - this is a raw lexer for the wasm text format. This is not +//! customizable, but if you'd like to iterate over raw tokens this is the +//! module for you. You likely won't use this much. +//! +//! * [`parser`] - this is the workhorse of this crate. The [`parser`] module +//! provides the [`Parse`][] trait primarily and utilities +//! around working with a [`Parser`](`parser::Parser`) to parse streams of +//! tokens. +//! +//! * [`Module`](crate::core::Module) - this contains an Abstract Syntax Tree +//! (AST) of the WebAssembly Text format (WAT) as well as the unofficial WAST +//! format. This also has a [`Module::encode`](crate::core::Module::encode) +//! method to emit a module in its binary form. +//! +//! # Stability and WebAssembly Features +//! +//! This crate provides support for many in-progress WebAssembly features such +//! as reference types, multi-value, etc. Be sure to check out the documentation +//! of the [`wast` crate](https://docs.rs/wast) for policy information on crate +//! stability vs WebAssembly Features. The tl;dr; version is that this crate +//! will issue semver-non-breaking releases which will break the parsing of the +//! text format. This crate, unlike `wast`, is expected to have numerous Rust +//! public API changes, all of which will be accompanied with a semver-breaking +//! release. +//! +//! # Compile-time Cargo features +//! +//! This crate has a `wasm-module` feature which is turned on by default which +//! includes all necessary support to parse full WebAssembly modules. If you +//! don't need this (for example you're parsing your own s-expression format) +//! then this feature can be disabled. +//! +//! [`Parse`]: parser::Parse +//! [`LexError`]: lexer::LexError + +#![deny(missing_docs, rustdoc::broken_intra_doc_links)] + +/// A macro to create a custom keyword parser. +/// +/// This macro is invoked in one of two forms: +/// +/// ``` +/// // keyword derived from the Rust identifier: +/// wast::custom_keyword!(foo); +/// +/// // or an explicitly specified string representation of the keyword: +/// wast::custom_keyword!(my_keyword = "the-wasm-keyword"); +/// ``` +/// +/// This can then be used to parse custom keyword for custom items, such as: +/// +/// ``` +/// use wast::parser::{Parser, Result, Parse}; +/// +/// struct InlineModule<'a> { +/// inline_text: &'a str, +/// } +/// +/// mod kw { +/// wast::custom_keyword!(inline); +/// } +/// +/// // Parse an inline string module of the form: +/// // +/// // (inline "(module (func))") +/// impl<'a> Parse<'a> for InlineModule<'a> { +/// fn parse(parser: Parser<'a>) -> Result { +/// parser.parse::()?; +/// Ok(InlineModule { +/// inline_text: parser.parse()?, +/// }) +/// } +/// } +/// ``` +/// +/// Note that the keyword name can only start with a lower-case letter, i.e. 'a'..'z'. +#[macro_export] +macro_rules! custom_keyword { + ($name:ident) => { + $crate::custom_keyword!($name = stringify!($name)); + }; + ($name:ident = $kw:expr) => { + #[allow(non_camel_case_types)] + #[allow(missing_docs)] + #[derive(Debug, Copy, Clone)] + pub struct $name(pub $crate::token::Span); + + impl<'a> $crate::parser::Parse<'a> for $name { + fn parse(parser: $crate::parser::Parser<'a>) -> $crate::parser::Result { + parser.step(|c| { + if let Some((kw, rest)) = c.keyword() { + if kw == $kw { + return Ok(($name(c.cur_span()), rest)); + } + } + Err(c.error(concat!("expected keyword `", $kw, "`"))) + }) + } + } + + impl $crate::parser::Peek for $name { + fn peek(cursor: $crate::parser::Cursor<'_>) -> bool { + if let Some((kw, _rest)) = cursor.keyword() { + kw == $kw + } else { + false + } + } + + fn display() -> &'static str { + concat!("`", $kw, "`") + } + } + }; +} + +/// A macro for defining custom reserved symbols. +/// +/// This is like `custom_keyword!` but for reserved symbols (`Token::Reserved`) +/// instead of keywords (`Token::Keyword`). +/// +/// ``` +/// use wast::parser::{Parser, Result, Parse}; +/// +/// // Define a custom reserved symbol, the "spaceship" operator: `<=>`. +/// wast::custom_reserved!(spaceship = "<=>"); +/// +/// /// A "three-way comparison" like `(<=> a b)` that returns -1 if `a` is less +/// /// than `b`, 0 if they're equal, and 1 if `a` is greater than `b`. +/// struct ThreeWayComparison<'a> { +/// lhs: wast::core::Expression<'a>, +/// rhs: wast::core::Expression<'a>, +/// } +/// +/// impl<'a> Parse<'a> for ThreeWayComparison<'a> { +/// fn parse(parser: Parser<'a>) -> Result { +/// parser.parse::()?; +/// let lhs = parser.parse()?; +/// let rhs = parser.parse()?; +/// Ok(ThreeWayComparison { lhs, rhs }) +/// } +/// } +/// ``` +#[macro_export] +macro_rules! custom_reserved { + ($name:ident) => { + $crate::custom_reserved!($name = stringify!($name)); + }; + ($name:ident = $rsv:expr) => { + #[allow(non_camel_case_types)] + #[allow(missing_docs)] + #[derive(Debug)] + pub struct $name(pub $crate::token::Span); + + impl<'a> $crate::parser::Parse<'a> for $name { + fn parse(parser: $crate::parser::Parser<'a>) -> $crate::parser::Result { + parser.step(|c| { + if let Some((rsv, rest)) = c.reserved() { + if rsv == $rsv { + return Ok(($name(c.cur_span()), rest)); + } + } + Err(c.error(concat!("expected reserved symbol `", $rsv, "`"))) + }) + } + } + + impl $crate::parser::Peek for $name { + fn peek(cursor: $crate::parser::Cursor<'_>) -> bool { + if let Some((rsv, _rest)) = cursor.reserved() { + rsv == $rsv + } else { + false + } + } + + fn display() -> &'static str { + concat!("`", $rsv, "`") + } + } + }; +} + +/// A macro, like [`custom_keyword`], to create a type which can be used to +/// parse/peek annotation directives. +/// +/// Note that when you're parsing custom annotations it can be somewhat tricky +/// due to the nature that most of them are skipped. You'll want to be sure to +/// consult the documentation of [`Parser::register_annotation`][register] when +/// using this macro. +/// +/// # Examples +/// +/// To see an example of how to use this macro, let's invent our own syntax for +/// the [producers section][section] which looks like: +/// +/// ```wat +/// (@producer "wat" "1.0.2") +/// ``` +/// +/// Here, for simplicity, we'll assume everything is a `processed-by` directive, +/// but you could get much more fancy with this as well. +/// +/// ``` +/// # use wast::*; +/// # use wast::parser::*; +/// +/// // First we define the custom annotation keyword we're using, and by +/// // convention we define it in an `annotation` module. +/// mod annotation { +/// wast::annotation!(producer); +/// } +/// +/// struct Producer<'a> { +/// name: &'a str, +/// version: &'a str, +/// } +/// +/// impl<'a> Parse<'a> for Producer<'a> { +/// fn parse(parser: Parser<'a>) -> Result { +/// // Remember that parser conventionally parse the *interior* of an +/// // s-expression, so we parse our `@producer` annotation and then we +/// // parse the payload of our annotation. +/// parser.parse::()?; +/// Ok(Producer { +/// name: parser.parse()?, +/// version: parser.parse()?, +/// }) +/// } +/// } +/// ``` +/// +/// Note though that this is only half of the parser for annotations. The other +/// half is calling the [`register_annotation`][register] method at the right +/// time to ensure the parser doesn't automatically skip our `@producer` +/// directive. Note that we *can't* call it inside the `Parse for Producer` +/// definition because that's too late and the annotation would already have +/// been skipped. +/// +/// Instead we'll need to call it from a higher level-parser before the +/// parenthesis have been parsed, like so: +/// +/// ``` +/// # use wast::*; +/// # use wast::parser::*; +/// struct Module<'a> { +/// fields: Vec>, +/// } +/// +/// impl<'a> Parse<'a> for Module<'a> { +/// fn parse(parser: Parser<'a>) -> Result { +/// // .. parse module header here ... +/// +/// // register our custom `@producer` annotation before we start +/// // parsing the parentheses of each field +/// let _r = parser.register_annotation("producer"); +/// +/// let mut fields = Vec::new(); +/// while !parser.is_empty() { +/// fields.push(parser.parens(|p| p.parse())?); +/// } +/// Ok(Module { fields }) +/// } +/// } +/// +/// enum ModuleField<'a> { +/// Producer(Producer<'a>), +/// // ... +/// } +/// # struct Producer<'a>(&'a str); +/// # impl<'a> Parse<'a> for Producer<'a> { +/// # fn parse(parser: Parser<'a>) -> Result { Ok(Producer(parser.parse()?)) } +/// # } +/// # mod annotation { wast::annotation!(producer); } +/// +/// impl<'a> Parse<'a> for ModuleField<'a> { +/// fn parse(parser: Parser<'a>) -> Result { +/// // and here `peek` works and our delegated parsing works because the +/// // annotation has been registered. +/// if parser.peek::() { +/// return Ok(ModuleField::Producer(parser.parse()?)); +/// } +/// +/// // .. typically we'd parse other module fields here... +/// +/// Err(parser.error("unknown module field")) +/// } +/// } +/// ``` +/// +/// [register]: crate::parser::Parser::register_annotation +/// [section]: https://github.com/WebAssembly/tool-conventions/blob/master/ProducersSection.md +#[macro_export] +macro_rules! annotation { + ($name:ident) => { + $crate::annotation!($name = stringify!($name)); + }; + ($name:ident = $annotation:expr) => { + #[allow(non_camel_case_types)] + #[allow(missing_docs)] + #[derive(Debug)] + pub struct $name(pub $crate::token::Span); + + impl<'a> $crate::parser::Parse<'a> for $name { + fn parse(parser: $crate::parser::Parser<'a>) -> $crate::parser::Result { + parser.step(|c| { + if let Some((a, rest)) = c.annotation() { + if a == $annotation { + return Ok(($name(c.cur_span()), rest)); + } + } + Err(c.error(concat!("expected annotation `@", $annotation, "`"))) + }) + } + } + + impl $crate::parser::Peek for $name { + fn peek(cursor: $crate::parser::Cursor<'_>) -> bool { + if let Some((a, _rest)) = cursor.annotation() { + a == $annotation + } else { + false + } + } + + fn display() -> &'static str { + concat!("`@", $annotation, "`") + } + } + }; +} + +pub mod lexer; +pub mod parser; +pub mod token; + +mod encode; +mod error; +mod gensym; +mod names; +pub use self::error::*; + +macro_rules! id { + ($($t:tt)*) => ($($t)*) +} + +#[cfg(feature = "wasm-module")] +id! { + mod wast; + mod wat; + pub use self::wast::*; + pub use self::wat::*; + + // Support for core wasm parsing + pub mod core; + + // Support for component model parsing + pub mod component; +} + +/// Common keyword used to parse WebAssembly text files. +pub mod kw { + custom_keyword!(after); + custom_keyword!(alias); + custom_keyword!(any); + custom_keyword!(anyfunc); + custom_keyword!(anyref); + custom_keyword!(arg); + custom_keyword!(array); + custom_keyword!(arrayref); + custom_keyword!(assert_exception); + custom_keyword!(assert_exhaustion); + custom_keyword!(assert_invalid); + custom_keyword!(assert_malformed); + custom_keyword!(assert_return); + custom_keyword!(assert_trap); + custom_keyword!(assert_unlinkable); + custom_keyword!(before); + custom_keyword!(binary); + custom_keyword!(block); + custom_keyword!(catch); + custom_keyword!(catch_all); + custom_keyword!(code); + custom_keyword!(component); + custom_keyword!(data); + custom_keyword!(dataref); + custom_keyword!(declare); + custom_keyword!(delegate); + custom_keyword!(r#do = "do"); + custom_keyword!(elem); + custom_keyword!(end); + custom_keyword!(tag); + custom_keyword!(export); + custom_keyword!(r#extern = "extern"); + custom_keyword!(externref); + custom_keyword!(eq); + custom_keyword!(eqref); + custom_keyword!(f32); + custom_keyword!(f32x4); + custom_keyword!(f64); + custom_keyword!(f64x2); + custom_keyword!(field); + custom_keyword!(first); + custom_keyword!(func); + custom_keyword!(funcref); + custom_keyword!(get); + custom_keyword!(global); + custom_keyword!(i16); + custom_keyword!(i16x8); + custom_keyword!(i31); + custom_keyword!(i31ref); + custom_keyword!(i32); + custom_keyword!(i32x4); + custom_keyword!(i64); + custom_keyword!(i64x2); + custom_keyword!(i8); + custom_keyword!(i8x16); + custom_keyword!(import); + custom_keyword!(instance); + custom_keyword!(instantiate); + custom_keyword!(invoke); + custom_keyword!(item); + custom_keyword!(last); + custom_keyword!(local); + custom_keyword!(memory); + custom_keyword!(module); + custom_keyword!(modulecode); + custom_keyword!(nan_arithmetic = "nan:arithmetic"); + custom_keyword!(nan_canonical = "nan:canonical"); + custom_keyword!(null); + custom_keyword!(nullref); + custom_keyword!(offset); + custom_keyword!(outer); + custom_keyword!(param); + custom_keyword!(parent); + custom_keyword!(passive); + custom_keyword!(quote); + custom_keyword!(r#else = "else"); + custom_keyword!(r#if = "if"); + custom_keyword!(r#loop = "loop"); + custom_keyword!(r#mut = "mut"); + custom_keyword!(r#type = "type"); + custom_keyword!(r#ref = "ref"); + custom_keyword!(ref_func = "ref.func"); + custom_keyword!(ref_null = "ref.null"); + custom_keyword!(register); + custom_keyword!(rec); + custom_keyword!(result); + custom_keyword!(shared); + custom_keyword!(start); + custom_keyword!(r#struct = "struct"); + custom_keyword!(sub); + custom_keyword!(table); + custom_keyword!(then); + custom_keyword!(r#try = "try"); + custom_keyword!(v128); + custom_keyword!(value); + custom_keyword!(s8); + custom_keyword!(s16); + custom_keyword!(s32); + custom_keyword!(s64); + custom_keyword!(u8); + custom_keyword!(u16); + custom_keyword!(u32); + custom_keyword!(u64); + custom_keyword!(char); + custom_keyword!(case); + custom_keyword!(refines); + custom_keyword!(record); + custom_keyword!(string); + custom_keyword!(bool_ = "bool"); + custom_keyword!(float32); + custom_keyword!(float64); + custom_keyword!(variant); + custom_keyword!(flags); + custom_keyword!(option); + custom_keyword!(tuple); + custom_keyword!(list); + custom_keyword!(error); + custom_keyword!(union); + custom_keyword!(canon); + custom_keyword!(lift); + custom_keyword!(lower); + custom_keyword!(enum_ = "enum"); + custom_keyword!(string_utf8 = "string-encoding=utf8"); + custom_keyword!(string_utf16 = "string-encoding=utf16"); + custom_keyword!(string_latin1_utf16 = "string-encoding=latin1+utf16"); + custom_keyword!(realloc); + custom_keyword!(post_return = "post-return"); + custom_keyword!(with); + custom_keyword!(core); + custom_keyword!(true_ = "true"); + custom_keyword!(false_ = "false"); +} + +/// Common annotations used to parse WebAssembly text files. +pub mod annotation { + annotation!(custom); + annotation!(name); +} diff --git a/crates/wastlhw/src/names.rs b/crates/wastlhw/src/names.rs new file mode 100644 index 000000000..b6cf06f44 --- /dev/null +++ b/crates/wastlhw/src/names.rs @@ -0,0 +1,86 @@ +use crate::token::{Id, Index}; +use crate::Error; +use std::collections::HashMap; + +#[derive(Default)] +pub struct Namespace<'a> { + names: HashMap, u32>, + count: u32, +} + +impl<'a> Namespace<'a> { + pub fn register(&mut self, name: Option>, desc: &str) -> Result { + let index = self.alloc(); + if let Some(name) = name { + if let Some(_prev) = self.names.insert(name, index) { + // FIXME: temporarily allow duplicately-named data and element + // segments. This is a sort of dumb hack to get the spec test + // suite working (ironically). + // + // So as background, the text format disallows duplicate + // identifiers, causing a parse error if they're found. There + // are two tests currently upstream, however, data.wast and + // elem.wast, which *look* like they have duplicately named + // element and data segments. These tests, however, are using + // pre-bulk-memory syntax where a bare identifier was the + // table/memory being initialized. In post-bulk-memory this + // identifier is the name of the segment. Since we implement + // post-bulk-memory features that means that we're parsing the + // memory/table-to-initialize as the name of the segment. + // + // This is technically incorrect behavior but no one is + // hopefully relying on this too much. To get the spec tests + // passing we ignore errors for elem/data segments. Once the + // spec tests get updated enough we can remove this condition + // and return errors for them. + if desc != "elem" && desc != "data" { + return Err(Error::new( + name.span(), + format!("duplicate {} identifier", desc), + )); + } + } + } + Ok(index) + } + + pub fn alloc(&mut self) -> u32 { + let index = self.count; + self.count += 1; + index + } + + pub fn register_specific(&mut self, name: Id<'a>, index: u32, desc: &str) -> Result<(), Error> { + if let Some(_prev) = self.names.insert(name, index) { + return Err(Error::new( + name.span(), + format!("duplicate identifier for {}", desc), + )); + } + Ok(()) + } + + pub fn resolve(&self, idx: &mut Index<'a>, desc: &str) -> Result { + let id = match idx { + Index::Num(n, _) => return Ok(*n), + Index::Id(id) => id, + }; + if let Some(&n) = self.names.get(id) { + *idx = Index::Num(n, id.span()); + return Ok(n); + } + Err(resolve_error(*id, desc)) + } +} + +pub fn resolve_error(id: Id<'_>, ns: &str) -> Error { + assert!( + !id.is_gensym(), + "symbol generated by `wast` itself cannot be resolved {:?}", + id + ); + Error::new( + id.span(), + format!("failed to find {} named `${}`", ns, id.name()), + ) +} diff --git a/crates/wastlhw/src/parser.rs b/crates/wastlhw/src/parser.rs new file mode 100644 index 000000000..aba5c5d40 --- /dev/null +++ b/crates/wastlhw/src/parser.rs @@ -0,0 +1,1313 @@ +//! Traits for parsing the WebAssembly Text format +//! +//! This module contains the traits, abstractions, and utilities needed to +//! define custom parsers for WebAssembly text format items. This module exposes +//! a recursive descent parsing strategy and centers around the +//! [`Parse`](crate::parser::Parse) trait for defining new fragments of +//! WebAssembly text syntax. +//! +//! The top-level [`parse`](crate::parser::parse) function can be used to fully parse AST fragments: +//! +//! ``` +//! use wast::Wat; +//! use wast::parser::{self, ParseBuffer}; +//! +//! # fn foo() -> Result<(), wast::Error> { +//! let wat = "(module (func))"; +//! let buf = ParseBuffer::new(wat)?; +//! let module = parser::parse::(&buf)?; +//! # Ok(()) +//! # } +//! ``` +//! +//! and you can also define your own new syntax with the +//! [`Parse`](crate::parser::Parse) trait: +//! +//! ``` +//! use wast::kw; +//! use wast::core::{Import, Func}; +//! use wast::parser::{Parser, Parse, Result}; +//! +//! // Fields of a WebAssembly which only allow imports and functions, and all +//! // imports must come before all the functions +//! struct OnlyImportsAndFunctions<'a> { +//! imports: Vec>, +//! functions: Vec>, +//! } +//! +//! impl<'a> Parse<'a> for OnlyImportsAndFunctions<'a> { +//! fn parse(parser: Parser<'a>) -> Result { +//! // While the second token is `import` (the first is `(`, so we care +//! // about the second) we parse an `ast::ModuleImport` inside of +//! // parentheses. The `parens` function here ensures that what we +//! // parse inside of it is surrounded by `(` and `)`. +//! let mut imports = Vec::new(); +//! while parser.peek2::() { +//! let import = parser.parens(|p| p.parse())?; +//! imports.push(import); +//! } +//! +//! // Afterwards we assume everything else is a function. Note that +//! // `parse` here is a generic function and type inference figures out +//! // that we're parsing functions here and imports above. +//! let mut functions = Vec::new(); +//! while !parser.is_empty() { +//! let func = parser.parens(|p| p.parse())?; +//! functions.push(func); +//! } +//! +//! Ok(OnlyImportsAndFunctions { imports, functions }) +//! } +//! } +//! ``` +//! +//! This module is heavily inspired by [`syn`](https://docs.rs/syn) so you can +//! likely also draw inspiration from the excellent examples in the `syn` crate. + +use crate::lexer::{Float, Integer, Lexer, Token}; +use crate::token::Span; +use crate::Error; +use std::cell::{Cell, RefCell}; +use std::collections::HashMap; +use std::fmt; +use std::usize; + +/// The maximum recursive depth of parens to parse. +/// +/// This is sort of a fundamental limitation of the way this crate is +/// designed. Everything is done through recursive descent parsing which +/// means, well, that we're recursively going down the stack as we parse +/// nested data structures. While we can handle this for wasm expressions +/// since that's a pretty local decision, handling this for nested +/// modules/components which be far trickier. For now we just say that when +/// the parser goes too deep we return an error saying there's too many +/// nested items. It would be great to not return an error here, though! +pub(crate) const MAX_PARENS_DEPTH: usize = 100; + +/// A top-level convenience parseing function that parss a `T` from `buf` and +/// requires that all tokens in `buf` are consume. +/// +/// This generic parsing function can be used to parse any `T` implementing the +/// [`Parse`] trait. It is not used from [`Parse`] trait implementations. +/// +/// # Examples +/// +/// ``` +/// use wast::Wat; +/// use wast::parser::{self, ParseBuffer}; +/// +/// # fn foo() -> Result<(), wast::Error> { +/// let wat = "(module (func))"; +/// let buf = ParseBuffer::new(wat)?; +/// let module = parser::parse::(&buf)?; +/// # Ok(()) +/// # } +/// ``` +/// +/// or parsing simply a fragment +/// +/// ``` +/// use wast::parser::{self, ParseBuffer}; +/// +/// # fn foo() -> Result<(), wast::Error> { +/// let wat = "12"; +/// let buf = ParseBuffer::new(wat)?; +/// let val = parser::parse::(&buf)?; +/// assert_eq!(val, 12); +/// # Ok(()) +/// # } +/// ``` +pub fn parse<'a, T: Parse<'a>>(buf: &'a ParseBuffer<'a>) -> Result { + let parser = buf.parser(); + let result = parser.parse()?; + if parser.cursor().advance_token().is_none() { + Ok(result) + } else { + Err(parser.error("extra tokens remaining after parse")) + } +} + +/// A trait for parsing a fragment of syntax in a recursive descent fashion. +/// +/// The [`Parse`] trait is main abstraction you'll be working with when defining +/// custom parser or custom syntax for your WebAssembly text format (or when +/// using the official format items). Almost all items in the +/// [`core`](crate::core) module implement the [`Parse`] trait, and you'll +/// commonly use this with: +/// +/// * The top-level [`parse`] function to parse an entire input. +/// * The intermediate [`Parser::parse`] function to parse an item out of an +/// input stream and then parse remaining items. +/// +/// Implementation of [`Parse`] take a [`Parser`] as input and will mutate the +/// parser as they parse syntax. Once a token is consume it cannot be +/// "un-consumed". Utilities such as [`Parser::peek`] and [`Parser::lookahead1`] +/// can be used to determine what to parse next. +/// +/// ## When to parse `(` and `)`? +/// +/// Conventionally types are not responsible for parsing their own `(` and `)` +/// tokens which surround the type. For example WebAssembly imports look like: +/// +/// ```text +/// (import "foo" "bar" (func (type 0))) +/// ``` +/// +/// but the [`Import`](crate::core::Import) type parser looks like: +/// +/// ``` +/// # use wast::kw; +/// # use wast::parser::{Parser, Parse, Result}; +/// # struct Import<'a>(&'a str); +/// impl<'a> Parse<'a> for Import<'a> { +/// fn parse(parser: Parser<'a>) -> Result { +/// parser.parse::()?; +/// // ... +/// # panic!() +/// } +/// } +/// ``` +/// +/// It is assumed here that the `(` and `)` tokens which surround an `import` +/// statement in the WebAssembly text format are parsed by the parent item +/// parsing `Import`. +/// +/// Note that this is just a convention, so it's not necessarily required for +/// all types. It's recommended that your types stick to this convention where +/// possible to avoid nested calls to [`Parser::parens`] or accidentally trying +/// to parse too many parenthesis. +/// +/// # Examples +/// +/// Let's say you want to define your own WebAssembly text format which only +/// contains imports and functions. You also require all imports to be listed +/// before all functions. An example [`Parse`] implementation might look like: +/// +/// ``` +/// use wast::core::{Import, Func}; +/// use wast::kw; +/// use wast::parser::{Parser, Parse, Result}; +/// +/// // Fields of a WebAssembly which only allow imports and functions, and all +/// // imports must come before all the functions +/// struct OnlyImportsAndFunctions<'a> { +/// imports: Vec>, +/// functions: Vec>, +/// } +/// +/// impl<'a> Parse<'a> for OnlyImportsAndFunctions<'a> { +/// fn parse(parser: Parser<'a>) -> Result { +/// // While the second token is `import` (the first is `(`, so we care +/// // about the second) we parse an `ast::ModuleImport` inside of +/// // parentheses. The `parens` function here ensures that what we +/// // parse inside of it is surrounded by `(` and `)`. +/// let mut imports = Vec::new(); +/// while parser.peek2::() { +/// let import = parser.parens(|p| p.parse())?; +/// imports.push(import); +/// } +/// +/// // Afterwards we assume everything else is a function. Note that +/// // `parse` here is a generic function and type inference figures out +/// // that we're parsing functions here and imports above. +/// let mut functions = Vec::new(); +/// while !parser.is_empty() { +/// let func = parser.parens(|p| p.parse())?; +/// functions.push(func); +/// } +/// +/// Ok(OnlyImportsAndFunctions { imports, functions }) +/// } +/// } +/// ``` +pub trait Parse<'a>: Sized { + /// Attempts to parse `Self` from `parser`, returning an error if it could + /// not be parsed. + /// + /// This method will mutate the state of `parser` after attempting to parse + /// an instance of `Self`. If an error happens then it is likely fatal and + /// there is no guarantee of how many tokens have been consumed from + /// `parser`. + /// + /// As recommended in the documentation of [`Parse`], implementations of + /// this function should not start out by parsing `(` and `)` tokens, but + /// rather parents calling recursive parsers should parse the `(` and `)` + /// tokens for their child item that's being parsed. + /// + /// # Errors + /// + /// This function will return an error if `Self` could not be parsed. Note + /// that creating an [`Error`] is not exactly a cheap operation, so + /// [`Error`] is typically fatal and propagated all the way back to the top + /// parse call site. + fn parse(parser: Parser<'a>) -> Result; +} + +/// A trait for types which be used to "peek" to see if they're the next token +/// in an input stream of [`Parser`]. +/// +/// Often when implementing [`Parse`] you'll need to query what the next token +/// in the stream is to figure out what to parse next. This [`Peek`] trait +/// defines the set of types that can be tested whether they're the next token +/// in the input stream. +/// +/// Implementations of [`Peek`] should only be present on types that consume +/// exactly one token (not zero, not more, exactly one). Types implementing +/// [`Peek`] should also typically implement [`Parse`] should also typically +/// implement [`Parse`]. +/// +/// See the documentation of [`Parser::peek`] for example usage. +pub trait Peek { + /// Tests to see whether this token is the first token within the [`Cursor`] + /// specified. + /// + /// Returns `true` if [`Parse`] for this type is highly likely to succeed + /// failing no other error conditions happening (like an integer literal + /// being too big). + fn peek(cursor: Cursor<'_>) -> bool; + + /// The same as `peek`, except it checks the token immediately following + /// the current token. + fn peek2(mut cursor: Cursor<'_>) -> bool { + if cursor.advance_token().is_some() { + Self::peek(cursor) + } else { + false + } + } + + /// Returns a human-readable name of this token to display when generating + /// errors about this token missing. + fn display() -> &'static str; +} + +/// A convenience type definition for `Result` where the error is hardwired to +/// [`Error`]. +pub type Result = std::result::Result; + +/// A low-level buffer of tokens which represents a completely lexed file. +/// +/// A `ParseBuffer` will immediately lex an entire file and then store all +/// tokens internally. A `ParseBuffer` only used to pass to the top-level +/// [`parse`] function. +pub struct ParseBuffer<'a> { + // list of tokens from the tokenized source (including whitespace and + // comments), and the second element is how to skip this token, if it can be + // skipped. + tokens: Box<[(Token<'a>, Cell)]>, + input: &'a str, + cur: Cell, + known_annotations: RefCell>, + depth: Cell, +} + +#[derive(Copy, Clone, Debug)] +enum NextTokenAt { + /// Haven't computed where the next token is yet. + Unknown, + /// Previously computed the index of the next token. + Index(usize), + /// There is no next token, this is the last token. + Eof, +} + +/// An in-progress parser for the tokens of a WebAssembly text file. +/// +/// A `Parser` is argument to the [`Parse`] trait and is now the input stream is +/// interacted with to parse new items. Cloning [`Parser`] or copying a parser +/// refers to the same stream of tokens to parse, you cannot clone a [`Parser`] +/// and clone two items. +/// +/// For more information about a [`Parser`] see its methods. +#[derive(Copy, Clone)] +pub struct Parser<'a> { + buf: &'a ParseBuffer<'a>, +} + +/// A helpful structure to perform a lookahead of one token to determine what to +/// parse. +/// +/// For more information see the [`Parser::lookahead1`] method. +pub struct Lookahead1<'a> { + parser: Parser<'a>, + attempts: Vec<&'static str>, +} + +/// An immutable cursor into a list of tokens. +/// +/// This cursor cannot be mutated but can be used to parse more tokens in a list +/// of tokens. Cursors are created from the [`Parser::step`] method. This is a +/// very low-level parsing structure and you likely won't use it much. +#[derive(Copy, Clone)] +pub struct Cursor<'a> { + parser: Parser<'a>, + cur: usize, +} + +impl ParseBuffer<'_> { + /// Creates a new [`ParseBuffer`] by lexing the given `input` completely. + /// + /// # Errors + /// + /// Returns an error if `input` fails to lex. + pub fn new(input: &str) -> Result> { + ParseBuffer::new_with_lexer(Lexer::new(input)) + } + + /// Creates a new [`ParseBuffer`] by lexing the given `input` completely. + /// + /// # Errors + /// + /// Returns an error if `input` fails to lex. + pub fn new_with_lexer(lexer: Lexer<'_>) -> Result> { + let mut tokens = Vec::new(); + let input = lexer.input(); + for token in lexer { + tokens.push((token?, Cell::new(NextTokenAt::Unknown))); + } + let ret = ParseBuffer { + tokens: tokens.into_boxed_slice(), + cur: Cell::new(0), + depth: Cell::new(0), + input, + known_annotations: Default::default(), + }; + ret.validate_annotations()?; + Ok(ret) + } + + fn parser(&self) -> Parser<'_> { + Parser { buf: self } + } + + // Validates that all annotations properly parse in that they have balanced + // delimiters. This is required since while parsing we generally skip + // annotations and there's no real opportunity to return a parse error. + fn validate_annotations(&self) -> Result<()> { + use crate::lexer::Token::*; + enum State { + None, + LParen, + Annotation { depth: usize, span: Span }, + } + let mut state = State::None; + for token in self.tokens.iter() { + state = match (&token.0, state) { + // From nothing, a `(` starts the search for an annotation + (LParen(_), State::None) => State::LParen, + // ... otherwise in nothing we alwyas preserve that state. + (_, State::None) => State::None, + + // If the previous state was an `LParen`, we may have an + // annotation if the next keyword is reserved + (Reserved(s), State::LParen) if s.starts_with('@') && !s.is_empty() => { + let offset = self.input_pos(s); + State::Annotation { + span: Span { offset }, + depth: 1, + } + } + // ... otherwise anything after an `LParen` kills the lparen + // state. + (_, State::LParen) => State::None, + + // Once we're in an annotation we need to balance parentheses, + // so handle the depth changes. + (LParen(_), State::Annotation { span, depth }) => State::Annotation { + span, + depth: depth + 1, + }, + (RParen(_), State::Annotation { depth: 1, .. }) => State::None, + (RParen(_), State::Annotation { span, depth }) => State::Annotation { + span, + depth: depth - 1, + }, + // ... and otherwise all tokens are allowed in annotations. + (_, s @ State::Annotation { .. }) => s, + }; + } + if let State::Annotation { span, .. } = state { + return Err(Error::new(span, "unclosed annotation".to_string())); + } + Ok(()) + } + + fn input_pos(&self, src: &str) -> usize { + src.as_ptr() as usize - self.input.as_ptr() as usize + } +} + +impl<'a> Parser<'a> { + /// Returns whether there are no more `Token` tokens to parse from this + /// [`Parser`]. + /// + /// This indicates that either we've reached the end of the input, or we're + /// a sub-[`Parser`] inside of a parenthesized expression and we've hit the + /// `)` token. + /// + /// Note that if `false` is returned there *may* be more comments. Comments + /// and whitespace are not considered for whether this parser is empty. + pub fn is_empty(self) -> bool { + match self.cursor().advance_token() { + Some(Token::RParen(_)) | None => true, + Some(_) => false, // more tokens to parse! + } + } + + pub(crate) fn has_meaningful_tokens(self) -> bool { + self.buf.tokens[self.cursor().cur..] + .iter() + .any(|(t, _)| match t { + Token::Whitespace(_) | Token::LineComment(_) | Token::BlockComment(_) => false, + _ => true, + }) + } + + /// Parses a `T` from this [`Parser`]. + /// + /// This method has a trivial definition (it simply calls + /// [`T::parse`](Parse::parse)) but is here for syntactic purposes. This is + /// what you'll call 99% of the time in a [`Parse`] implementation in order + /// to parse sub-items. + /// + /// Typically you always want to use `?` with the result of this method, you + /// should not handle errors and decide what else to parse. To handle + /// branches in parsing, use [`Parser::peek`]. + /// + /// # Examples + /// + /// A good example of using `parse` is to see how the [`TableType`] type is + /// parsed in this crate. A [`TableType`] is defined in the official + /// specification as [`tabletype`][spec] and is defined as: + /// + /// [spec]: https://webassembly.github.io/spec/core/text/types.html#table-types + /// + /// ```text + /// tabletype ::= lim:limits et:reftype + /// ``` + /// + /// so to parse a [`TableType`] we recursively need to parse a [`Limits`] + /// and a [`RefType`] + /// + /// ``` + /// # use wast::core::*; + /// # use wast::parser::*; + /// struct TableType<'a> { + /// limits: Limits, + /// elem: RefType<'a>, + /// } + /// + /// impl<'a> Parse<'a> for TableType<'a> { + /// fn parse(parser: Parser<'a>) -> Result { + /// // parse the `lim` then `et` in sequence + /// Ok(TableType { + /// limits: parser.parse()?, + /// elem: parser.parse()?, + /// }) + /// } + /// } + /// ``` + /// + /// [`Limits`]: crate::core::Limits + /// [`TableType`]: crate::core::TableType + /// [`RefType`]: crate::core::RefType + pub fn parse>(self) -> Result { + T::parse(self) + } + + /// Performs a cheap test to see whether the current token in this stream is + /// `T`. + /// + /// This method can be used to efficiently determine what next to parse. The + /// [`Peek`] trait is defined for types which can be used to test if they're + /// the next item in the input stream. + /// + /// Nothing is actually parsed in this method, nor does this mutate the + /// state of this [`Parser`]. Instead, this simply performs a check. + /// + /// This method is frequently combined with the [`Parser::lookahead1`] + /// method to automatically produce nice error messages if some tokens + /// aren't found. + /// + /// # Examples + /// + /// For an example of using the `peek` method let's take a look at parsing + /// the [`Limits`] type. This is [defined in the official spec][spec] as: + /// + /// ```text + /// limits ::= n:u32 + /// | n:u32 m:u32 + /// ``` + /// + /// which means that it's either one `u32` token or two, so we need to know + /// whether to consume two tokens or one: + /// + /// ``` + /// # use wast::parser::*; + /// struct Limits { + /// min: u32, + /// max: Option, + /// } + /// + /// impl<'a> Parse<'a> for Limits { + /// fn parse(parser: Parser<'a>) -> Result { + /// // Always parse the first number... + /// let min = parser.parse()?; + /// + /// // ... and then test if there's a second number before parsing + /// let max = if parser.peek::() { + /// Some(parser.parse()?) + /// } else { + /// None + /// }; + /// + /// Ok(Limits { min, max }) + /// } + /// } + /// ``` + /// + /// [spec]: https://webassembly.github.io/spec/core/text/types.html#limits + /// [`Limits`]: crate::core::Limits + pub fn peek(self) -> bool { + T::peek(self.cursor()) + } + + /// Same as the [`Parser::peek`] method, except checks the next token, not + /// the current token. + pub fn peek2(self) -> bool { + let mut cursor = self.cursor(); + if cursor.advance_token().is_some() { + T::peek(cursor) + } else { + false + } + } + + /// Same as the [`Parser::peek2`] method, except checks the next next token, + /// not the next token. + pub fn peek3(self) -> bool { + let mut cursor = self.cursor(); + if cursor.advance_token().is_some() && cursor.advance_token().is_some() { + T::peek(cursor) + } else { + false + } + } + + /// A helper structure to perform a sequence of `peek` operations and if + /// they all fail produce a nice error message. + /// + /// This method purely exists for conveniently producing error messages and + /// provides no functionality that [`Parser::peek`] doesn't already give. + /// The [`Lookahead1`] structure has one main method [`Lookahead1::peek`], + /// which is the same method as [`Parser::peek`]. The difference is that the + /// [`Lookahead1::error`] method needs no arguments. + /// + /// # Examples + /// + /// Let's look at the parsing of [`Index`]. This type is either a `u32` or + /// an [`Id`] and is used in name resolution primarily. The [official + /// grammar for an index][spec] is: + /// + /// ```text + /// idx ::= x:u32 + /// | v:id + /// ``` + /// + /// Which is to say that an index is either a `u32` or an [`Id`]. When + /// parsing an [`Index`] we can do: + /// + /// ``` + /// # use wast::token::*; + /// # use wast::parser::*; + /// enum Index<'a> { + /// Num(u32), + /// Id(Id<'a>), + /// } + /// + /// impl<'a> Parse<'a> for Index<'a> { + /// fn parse(parser: Parser<'a>) -> Result { + /// let mut l = parser.lookahead1(); + /// if l.peek::() { + /// Ok(Index::Id(parser.parse()?)) + /// } else if l.peek::() { + /// Ok(Index::Num(parser.parse()?)) + /// } else { + /// // produces error message of `expected identifier or u32` + /// Err(l.error()) + /// } + /// } + /// } + /// ``` + /// + /// [spec]: https://webassembly.github.io/spec/core/text/modules.html#indices + /// [`Index`]: crate::token::Index + /// [`Id`]: crate::token::Id + pub fn lookahead1(self) -> Lookahead1<'a> { + Lookahead1 { + attempts: Vec::new(), + parser: self, + } + } + + /// Parse an item surrounded by parentheses. + /// + /// WebAssembly's text format is all based on s-expressions, so naturally + /// you're going to want to parse a lot of parenthesized things! As noted in + /// the documentation of [`Parse`] you typically don't parse your own + /// surrounding `(` and `)` tokens, but the parser above you parsed them for + /// you. This is method method the parser above you uses. + /// + /// This method will parse a `(` token, and then call `f` on a sub-parser + /// which when finished asserts that a `)` token is the next token. This + /// requires that `f` consumes all tokens leading up to the paired `)`. + /// + /// Usage will often simply be `parser.parens(|p| p.parse())?` to + /// automatically parse a type within parentheses, but you can, as always, + /// go crazy and do whatever you'd like too. + /// + /// # Examples + /// + /// A good example of this is to see how a `Module` is parsed. This isn't + /// the exact definition, but it's close enough! + /// + /// ``` + /// # use wast::kw; + /// # use wast::core::*; + /// # use wast::parser::*; + /// struct Module<'a> { + /// fields: Vec>, + /// } + /// + /// impl<'a> Parse<'a> for Module<'a> { + /// fn parse(parser: Parser<'a>) -> Result { + /// // Modules start out with a `module` keyword + /// parser.parse::()?; + /// + /// // And then everything else is `(field ...)`, so while we've got + /// // items left we continuously parse parenthesized items. + /// let mut fields = Vec::new(); + /// while !parser.is_empty() { + /// fields.push(parser.parens(|p| p.parse())?); + /// } + /// Ok(Module { fields }) + /// } + /// } + /// ``` + pub fn parens(self, f: impl FnOnce(Parser<'a>) -> Result) -> Result { + self.buf.depth.set(self.buf.depth.get() + 1); + let before = self.buf.cur.get(); + let res = self.step(|cursor| { + let mut cursor = match cursor.lparen() { + Some(rest) => rest, + None => return Err(cursor.error("expected `(`")), + }; + cursor.parser.buf.cur.set(cursor.cur); + let result = f(cursor.parser)?; + cursor.cur = cursor.parser.buf.cur.get(); + match cursor.rparen() { + Some(rest) => Ok((result, rest)), + None => Err(cursor.error("expected `)`")), + } + }); + self.buf.depth.set(self.buf.depth.get() - 1); + if res.is_err() { + self.buf.cur.set(before); + } + res + } + + /// Return the depth of nested parens we've parsed so far. + /// + /// This is a low-level method that is only useful for implementing + /// recursion limits in custom parsers. + pub fn parens_depth(&self) -> usize { + self.buf.depth.get() + } + + /// Checks that the parser parens depth hasn't exceeded the maximum depth. + pub(crate) fn depth_check(&self) -> Result<()> { + if self.parens_depth() > MAX_PARENS_DEPTH { + Err(self.error("item nesting too deep")) + } else { + Ok(()) + } + } + + fn cursor(self) -> Cursor<'a> { + Cursor { + parser: self, + cur: self.buf.cur.get(), + } + } + + /// A low-level parsing method you probably won't use. + /// + /// This is used to implement parsing of the most primitive types in the + /// [`core`](crate::core) module. You probably don't want to use this, but + /// probably want to use something like [`Parser::parse`] or + /// [`Parser::parens`]. + pub fn step(self, f: F) -> Result + where + F: FnOnce(Cursor<'a>) -> Result<(T, Cursor<'a>)>, + { + let (result, cursor) = f(self.cursor())?; + self.buf.cur.set(cursor.cur); + Ok(result) + } + + /// Creates an error whose line/column information is pointing at the + /// current token. + /// + /// This is used to produce human-readable error messages which point to the + /// right location in the input stream, and the `msg` here is arbitrary text + /// used to associate with the error and indicate why it was generated. + pub fn error(self, msg: impl fmt::Display) -> Error { + self.error_at(self.cursor().cur_span(), &msg) + } + + fn error_at(self, span: Span, msg: &dyn fmt::Display) -> Error { + Error::parse(span, self.buf.input, msg.to_string()) + } + + /// Returns the span of the current token + pub fn cur_span(&self) -> Span { + self.cursor().cur_span() + } + + /// Returns the span of the previous token + pub fn prev_span(&self) -> Span { + self.cursor() + .prev_span() + .unwrap_or_else(|| Span::from_offset(0)) + } + + /// Registers a new known annotation with this parser to allow parsing + /// annotations with this name. + /// + /// [WebAssembly annotations][annotation] are a proposal for the text format + /// which allows decorating the text format with custom structured + /// information. By default all annotations are ignored when parsing, but + /// the whole purpose of them is to sometimes parse them! + /// + /// To support parsing text annotations this method is used to allow + /// annotations and their tokens to *not* be skipped. Once an annotation is + /// registered with this method, then while the return value has not been + /// dropped (e.g. the scope of where this function is called) annotations + /// with the name `annotation` will be parse of the token stream and not + /// implicitly skipped. + /// + /// # Skipping annotations + /// + /// The behavior of skipping unknown/unregistered annotations can be + /// somewhat subtle and surprising, so if you're interested in parsing + /// annotations it's important to point out the importance of this method + /// and where to call it. + /// + /// Generally when parsing tokens you'll be bottoming out in various + /// `Cursor` methods. These are all documented as advancing the stream as + /// much as possible to the next token, skipping "irrelevant stuff" like + /// comments, whitespace, etc. The `Cursor` methods will also skip unknown + /// annotations. This means that if you parse *any* token, it will skip over + /// any number of annotations that are unknown at all times. + /// + /// To parse an annotation you must, before parsing any token of the + /// annotation, register the annotation via this method. This includes the + /// beginning `(` token, which is otherwise skipped if the annotation isn't + /// marked as registered. Typically parser parse the *contents* of an + /// s-expression, so this means that the outer parser of an s-expression + /// must register the custom annotation name, rather than the inner parser. + /// + /// # Return + /// + /// This function returns an RAII guard which, when dropped, will unregister + /// the `annotation` given. Parsing `annotation` is only supported while the + /// returned value is still alive, and once dropped the parser will go back + /// to skipping annotations with the name `annotation`. + /// + /// # Example + /// + /// Let's see an example of how the `@name` annotation is parsed for modules + /// to get an idea of how this works: + /// + /// ``` + /// # use wast::kw; + /// # use wast::token::NameAnnotation; + /// # use wast::parser::*; + /// struct Module<'a> { + /// name: Option>, + /// } + /// + /// impl<'a> Parse<'a> for Module<'a> { + /// fn parse(parser: Parser<'a>) -> Result { + /// // Modules start out with a `module` keyword + /// parser.parse::()?; + /// + /// // Next may be `(@name "foo")`. Typically this annotation would + /// // skipped, but we don't want it skipped, so we register it. + /// // Note that the parse implementation of + /// // `Option` is the one that consumes the + /// // parentheses here. + /// let _r = parser.register_annotation("name"); + /// let name = parser.parse()?; + /// + /// // ... and normally you'd otherwise parse module fields here ... + /// + /// Ok(Module { name }) + /// } + /// } + /// ``` + /// + /// Another example is how we parse the `@custom` annotation. Note that this + /// is parsed as part of `ModuleField`, so note how the annotation is + /// registered *before* we parse the parentheses of the annotation. + /// + /// ``` + /// # use wast::{kw, annotation}; + /// # use wast::core::Custom; + /// # use wast::parser::*; + /// struct Module<'a> { + /// fields: Vec>, + /// } + /// + /// impl<'a> Parse<'a> for Module<'a> { + /// fn parse(parser: Parser<'a>) -> Result { + /// // Modules start out with a `module` keyword + /// parser.parse::()?; + /// + /// // register the `@custom` annotation *first* before we start + /// // parsing fields, because each field is contained in + /// // parentheses and to parse the parentheses of an annotation we + /// // have to known to not skip it. + /// let _r = parser.register_annotation("custom"); + /// + /// let mut fields = Vec::new(); + /// while !parser.is_empty() { + /// fields.push(parser.parens(|p| p.parse())?); + /// } + /// Ok(Module { fields }) + /// } + /// } + /// + /// enum ModuleField<'a> { + /// Custom(Custom<'a>), + /// // ... + /// } + /// + /// impl<'a> Parse<'a> for ModuleField<'a> { + /// fn parse(parser: Parser<'a>) -> Result { + /// // Note that because we have previously registered the `@custom` + /// // annotation with the parser we known that `peek` methods like + /// // this, working on the annotation token, are enabled to ever + /// // return `true`. + /// if parser.peek::() { + /// return Ok(ModuleField::Custom(parser.parse()?)); + /// } + /// + /// // .. typically we'd parse other module fields here... + /// + /// Err(parser.error("unknown module field")) + /// } + /// } + /// ``` + /// + /// [annotation]: https://github.com/WebAssembly/annotations + pub fn register_annotation<'b>(self, annotation: &'b str) -> impl Drop + 'b + where + 'a: 'b, + { + let mut annotations = self.buf.known_annotations.borrow_mut(); + if !annotations.contains_key(annotation) { + annotations.insert(annotation.to_string(), 0); + } + *annotations.get_mut(annotation).unwrap() += 1; + + return RemoveOnDrop(self, annotation); + + struct RemoveOnDrop<'a>(Parser<'a>, &'a str); + + impl Drop for RemoveOnDrop<'_> { + fn drop(&mut self) { + let mut annotations = self.0.buf.known_annotations.borrow_mut(); + let slot = annotations.get_mut(self.1).unwrap(); + *slot -= 1; + } + } + } +} + +impl<'a> Cursor<'a> { + /// Returns the span of the next `Token` token. + /// + /// Does not take into account whitespace or comments. + pub fn cur_span(&self) -> Span { + let offset = match self.clone().advance_token() { + Some(t) => self.parser.buf.input_pos(t.src()), + None => self.parser.buf.input.len(), + }; + Span { offset } + } + + /// Returns the span of the previous `Token` token. + /// + /// Does not take into account whitespace or comments. + pub(crate) fn prev_span(&self) -> Option { + let (token, _) = self.parser.buf.tokens.get(self.cur.checked_sub(1)?)?; + Some(Span { + offset: self.parser.buf.input_pos(token.src()), + }) + } + + /// Same as [`Parser::error`], but works with the current token in this + /// [`Cursor`] instead. + pub fn error(&self, msg: impl fmt::Display) -> Error { + self.parser.error_at(self.cur_span(), &msg) + } + + /// Attempts to advance this cursor if the current token is a `(`. + /// + /// If the current token is `(`, returns a new [`Cursor`] pointing at the + /// rest of the tokens in the stream. Otherwise returns `None`. + /// + /// This function will automatically skip over any comments, whitespace, or + /// unknown annotations. + pub fn lparen(mut self) -> Option { + match self.advance_token()? { + Token::LParen(_) => Some(self), + _ => None, + } + } + + /// Attempts to advance this cursor if the current token is a `)`. + /// + /// If the current token is `)`, returns a new [`Cursor`] pointing at the + /// rest of the tokens in the stream. Otherwise returns `None`. + /// + /// This function will automatically skip over any comments, whitespace, or + /// unknown annotations. + pub fn rparen(mut self) -> Option { + match self.advance_token()? { + Token::RParen(_) => Some(self), + _ => None, + } + } + + /// Attempts to advance this cursor if the current token is a + /// [`Token::Id`](crate::lexer::Token) + /// + /// If the current token is `Id`, returns the identifier minus the leading + /// `$` character as well as a new [`Cursor`] pointing at the rest of the + /// tokens in the stream. Otherwise returns `None`. + /// + /// This function will automatically skip over any comments, whitespace, or + /// unknown annotations. + pub fn id(mut self) -> Option<(&'a str, Self)> { + match self.advance_token()? { + Token::Id(id) => Some((&id[1..], self)), + _ => None, + } + } + + /// Attempts to advance this cursor if the current token is a + /// [`Token::Keyword`](crate::lexer::Token) + /// + /// If the current token is `Keyword`, returns the keyword as well as a new + /// [`Cursor`] pointing at the rest of the tokens in the stream. Otherwise + /// returns `None`. + /// + /// This function will automatically skip over any comments, whitespace, or + /// unknown annotations. + pub fn keyword(mut self) -> Option<(&'a str, Self)> { + match self.advance_token()? { + Token::Keyword(id) => Some((id, self)), + _ => None, + } + } + + /// Attempts to advance this cursor if the current token is a + /// [`Token::Reserved`](crate::lexer::Token) + /// + /// If the current token is `Reserved`, returns the reserved token as well + /// as a new [`Cursor`] pointing at the rest of the tokens in the stream. + /// Otherwise returns `None`. + /// + /// This function will automatically skip over any comments, whitespace, or + /// unknown annotations. + pub fn reserved(mut self) -> Option<(&'a str, Self)> { + match self.advance_token()? { + Token::Reserved(id) => Some((id, self)), + _ => None, + } + } + + /// Attempts to advance this cursor if the current token is a + /// [`Token::Integer`](crate::lexer::Token) + /// + /// If the current token is `Integer`, returns the integer as well as a new + /// [`Cursor`] pointing at the rest of the tokens in the stream. Otherwise + /// returns `None`. + /// + /// This function will automatically skip over any comments, whitespace, or + /// unknown annotations. + pub fn integer(mut self) -> Option<(&'a Integer<'a>, Self)> { + match self.advance_token()? { + Token::Integer(i) => Some((i, self)), + _ => None, + } + } + + /// Attempts to advance this cursor if the current token is a + /// [`Token::Float`](crate::lexer::Token) + /// + /// If the current token is `Float`, returns the float as well as a new + /// [`Cursor`] pointing at the rest of the tokens in the stream. Otherwise + /// returns `None`. + /// + /// This function will automatically skip over any comments, whitespace, or + /// unknown annotations. + pub fn float(mut self) -> Option<(&'a Float<'a>, Self)> { + match self.advance_token()? { + Token::Float(f) => Some((f, self)), + _ => None, + } + } + + /// Attempts to advance this cursor if the current token is a + /// [`Token::String`](crate::lexer::Token) + /// + /// If the current token is `String`, returns the byte value of the string + /// as well as a new [`Cursor`] pointing at the rest of the tokens in the + /// stream. Otherwise returns `None`. + /// + /// This function will automatically skip over any comments, whitespace, or + /// unknown annotations. + pub fn string(mut self) -> Option<(&'a [u8], Self)> { + match self.advance_token()? { + Token::String(s) => Some((s.val(), self)), + _ => None, + } + } + + /// Attempts to advance this cursor if the current token is a + /// [`Token::Reserved`](crate::lexer::Token) and looks like the start of an + /// annotation. + /// + /// [Annotations][annotation] are a WebAssembly proposal for the text format + /// which allows placing structured text inside of a text file, for example + /// to specify the name section or other custom sections. + /// + /// This function will attempt to see if the current token is the `@foo` + /// part of the annotation. This requires the previous token to be `(` and + /// the current token is `Reserved` which starts with `@` and has a nonzero + /// length for the following name. + /// + /// Note that this will skip *unknown* annoations. Only pre-registered + /// annotations will be returned here. + /// + /// This function will automatically skip over any comments, whitespace, or + /// unknown annotations. + /// + /// [annotation]: https://github.com/WebAssembly/annotations + pub fn annotation(self) -> Option<(&'a str, Self)> { + let (token, cursor) = self.reserved()?; + if !token.starts_with('@') || token.len() <= 1 { + return None; + } + match &self.parser.buf.tokens.get(self.cur.wrapping_sub(1))?.0 { + Token::LParen(_) => Some((&token[1..], cursor)), + _ => None, + } + } + + /// Attempts to advance this cursor if the current token is a + /// [`Token::LineComment`](crate::lexer::Token) or a + /// [`Token::BlockComment`](crate::lexer::Token) + /// + /// This function will only skip whitespace, no other tokens. + pub fn comment(mut self) -> Option<(&'a str, Self)> { + let comment = loop { + match &self.parser.buf.tokens.get(self.cur)?.0 { + Token::LineComment(c) | Token::BlockComment(c) => { + self.cur += 1; + break c; + } + Token::Whitespace(_) => { + self.cur += 1; + } + _ => return None, + } + }; + Some((comment, self)) + } + + fn advance_token(&mut self) -> Option<&'a Token<'a>> { + let known_annotations = self.parser.buf.known_annotations.borrow(); + let is_known_annotation = |name: &str| match known_annotations.get(name) { + Some(0) | None => false, + Some(_) => true, + }; + + loop { + let (token, next) = self.parser.buf.tokens.get(self.cur)?; + + // If we're currently pointing at a token, and it's not the start + // of an annotation, then we return that token and advance + // ourselves to just after that token. + match token { + Token::Whitespace(_) | Token::LineComment(_) | Token::BlockComment(_) => {} + _ => match self.annotation_start() { + Some(n) if !is_known_annotation(n) => {} + _ => { + self.cur += 1; + return Some(token); + } + }, + } + + // ... otherwise we need to skip the current token, and possibly + // more. Here we're skipping whitespace, comments, annotations, etc. + // Basically stuff that's intended to not be that relevant to the + // text format. This is a pretty common operation, though, and we + // may do it multiple times through peeks and such. As a result + // this is somewhat cached. + // + // The `next` field, if "unknown", means we haven't calculated the + // next token. Otherwise it's an index of where to resume searching + // for the next token. + // + // Note that this entire operation happens in a loop (hence the + // "somewhat cached") because the set of known annotations is + // dynamic and we can't cache which annotations are skipped. What we + // can do though is cache the number of tokens in the annotation so + // we know how to skip ahead of it. + match next.get() { + NextTokenAt::Unknown => match self.find_next() { + Some(i) => { + next.set(NextTokenAt::Index(i)); + self.cur = i; + } + None => { + next.set(NextTokenAt::Eof); + return None; + } + }, + NextTokenAt::Eof => return None, + NextTokenAt::Index(i) => self.cur = i, + } + } + } + + fn annotation_start(&self) -> Option<&'a str> { + match self.parser.buf.tokens.get(self.cur).map(|p| &p.0) { + Some(Token::LParen(_)) => {} + _ => return None, + } + let reserved = match self.parser.buf.tokens.get(self.cur + 1).map(|p| &p.0) { + Some(Token::Reserved(n)) => n, + _ => return None, + }; + if reserved.starts_with('@') && reserved.len() > 1 { + Some(&reserved[1..]) + } else { + None + } + } + + /// Finds the next "real" token from the current position onwards. + /// + /// This is a somewhat expensive operation to call quite a lot, so it's + /// cached in the token list. See the comment above in `advance_token` for + /// how this works. + /// + /// Returns the index of the next relevant token to parse + fn find_next(mut self) -> Option { + // If we're pointing to the start of annotation we need to skip it + // in its entirety, so match the parentheses and figure out where + // the annotation ends. + if self.annotation_start().is_some() { + let mut depth = 1; + self.cur += 1; + while depth > 0 { + match &self.parser.buf.tokens.get(self.cur)?.0 { + Token::LParen(_) => depth += 1, + Token::RParen(_) => depth -= 1, + _ => {} + } + self.cur += 1; + } + return Some(self.cur); + } + + // ... otherwise we're pointing at whitespace/comments, so we need to + // figure out how many of them we can skip. + loop { + let (token, _) = self.parser.buf.tokens.get(self.cur)?; + // and otherwise we skip all comments/whitespace and otherwise + // get real intersted once a normal `Token` pops up. + match token { + Token::Whitespace(_) | Token::LineComment(_) | Token::BlockComment(_) => { + self.cur += 1 + } + _ => return Some(self.cur), + } + } + } +} + +impl Lookahead1<'_> { + /// Attempts to see if `T` is the next token in the [`Parser`] this + /// [`Lookahead1`] references. + /// + /// For more information see [`Parser::lookahead1`] and [`Parser::peek`] + pub fn peek(&mut self) -> bool { + if self.parser.peek::() { + true + } else { + self.attempts.push(T::display()); + false + } + } + + /// Generates an error message saying that one of the tokens passed to + /// [`Lookahead1::peek`] method was expected. + /// + /// Before calling this method you should call [`Lookahead1::peek`] for all + /// possible tokens you'd like to parse. + pub fn error(self) -> Error { + match self.attempts.len() { + 0 => { + if self.parser.is_empty() { + self.parser.error("unexpected end of input") + } else { + self.parser.error("unexpected token") + } + } + 1 => { + let message = format!("unexpected token, expected {}", self.attempts[0]); + self.parser.error(&message) + } + 2 => { + let message = format!( + "unexpected token, expected {} or {}", + self.attempts[0], self.attempts[1] + ); + self.parser.error(&message) + } + _ => { + let join = self.attempts.join(", "); + let message = format!("unexpected token, expected one of: {}", join); + self.parser.error(&message) + } + } + } +} + +impl<'a, T: Peek + Parse<'a>> Parse<'a> for Option { + fn parse(parser: Parser<'a>) -> Result> { + if parser.peek::() { + Ok(Some(parser.parse()?)) + } else { + Ok(None) + } + } +} diff --git a/crates/wastlhw/src/token.rs b/crates/wastlhw/src/token.rs new file mode 100644 index 000000000..f6f22d095 --- /dev/null +++ b/crates/wastlhw/src/token.rs @@ -0,0 +1,697 @@ +//! Common tokens that implement the [`Parse`] trait which are otherwise not +//! associated specifically with the wasm text format per se (useful in other +//! contexts too perhaps). + +use crate::annotation; +use crate::lexer::FloatVal; +use crate::parser::{Cursor, Parse, Parser, Peek, Result}; +use std::fmt; +use std::hash::{Hash, Hasher}; +use std::str; + +/// A position in the original source stream, used to render errors. +#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)] +pub struct Span { + pub(crate) offset: usize, +} + +impl Span { + /// Construct a `Span` from a byte offset in the source file. + pub fn from_offset(offset: usize) -> Self { + Span { offset } + } + + /// Returns the line/column information of this span within `text`. + /// Line and column numbers are 0-indexed. User presentation is typically + /// 1-indexed, but 0-indexing is appropriate for internal use with + /// iterators and slices. + pub fn linecol_in(&self, text: &str) -> (usize, usize) { + let mut cur = 0; + // Use split_terminator instead of lines so that if there is a `\r`, + // it is included in the offset calculation. The `+1` values below + // account for the `\n`. + for (i, line) in text.split_terminator('\n').enumerate() { + if cur + line.len() + 1 > self.offset { + return (i, self.offset - cur); + } + cur += line.len() + 1; + } + (text.lines().count(), 0) + } + + /// Returns the byte offset of this span. + pub fn offset(&self) -> usize { + self.offset + } +} + +/// An identifier in a WebAssembly module, prefixed by `$` in the textual +/// format. +/// +/// An identifier is used to symbolically refer to items in a a wasm module, +/// typically via the [`Index`] type. +#[derive(Copy, Clone)] +pub struct Id<'a> { + name: &'a str, + gen: u32, + span: Span, +} + +impl<'a> Id<'a> { + fn new(name: &'a str, span: Span) -> Id<'a> { + Id { name, gen: 0, span } + } + + pub(crate) fn gensym(span: Span, gen: u32) -> Id<'a> { + Id { + name: "gensym", + gen, + span, + } + } + + /// Returns the underlying name of this identifier. + /// + /// The name returned does not contain the leading `$`. + pub fn name(&self) -> &'a str { + self.name + } + + /// Returns span of this identifier in the original source + pub fn span(&self) -> Span { + self.span + } + + pub(crate) fn is_gensym(&self) -> bool { + self.gen != 0 + } +} + +impl<'a> Hash for Id<'a> { + fn hash(&self, hasher: &mut H) { + self.name.hash(hasher); + self.gen.hash(hasher); + } +} + +impl<'a> PartialEq for Id<'a> { + fn eq(&self, other: &Id<'a>) -> bool { + self.name == other.name && self.gen == other.gen + } +} + +impl<'a> Eq for Id<'a> {} + +impl<'a> Parse<'a> for Id<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.step(|c| { + if let Some((name, rest)) = c.id() { + return Ok((Id::new(name, c.cur_span()), rest)); + } + Err(c.error("expected an identifier")) + }) + } +} + +impl fmt::Debug for Id<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + if self.gen != 0 { + f.debug_struct("Id").field("gen", &self.gen).finish() + } else { + self.name.fmt(f) + } + } +} + +impl Peek for Id<'_> { + fn peek(cursor: Cursor<'_>) -> bool { + cursor.id().is_some() + } + + fn display() -> &'static str { + "an identifier" + } +} + +/// A reference to another item in a wasm module. +/// +/// This type is used for items referring to other items (such as `call $foo` +/// referencing function `$foo`). References can be either an index (u32) or an +/// [`Id`] in the textual format. +/// +/// The emission phase of a module will ensure that `Index::Id` is never used +/// and switch them all to `Index::Num`. +#[derive(Copy, Clone, Debug)] +pub enum Index<'a> { + /// A numerical index that this references. The index space this is + /// referencing is implicit based on where this [`Index`] is stored. + Num(u32, Span), + /// A human-readable identifier this references. Like `Num`, the namespace + /// this references is based on where this is stored. + Id(Id<'a>), +} + +impl Index<'_> { + /// Returns the source location where this `Index` was defined. + pub fn span(&self) -> Span { + match self { + Index::Num(_, span) => *span, + Index::Id(id) => id.span(), + } + } + + pub(crate) fn is_resolved(&self) -> bool { + match self { + Index::Num(..) => true, + _ => false, + } + } +} + +impl<'a> Parse<'a> for Index<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + Ok(Index::Id(parser.parse()?)) + } else if l.peek::() { + let (val, span) = parser.parse()?; + Ok(Index::Num(val, span)) + } else { + Err(l.error()) + } + } +} + +impl Peek for Index<'_> { + fn peek(cursor: Cursor<'_>) -> bool { + u32::peek(cursor) || Id::peek(cursor) + } + + fn display() -> &'static str { + "an index" + } +} + +impl<'a> From> for Index<'a> { + fn from(id: Id<'a>) -> Index<'a> { + Index::Id(id) + } +} + +impl PartialEq for Index<'_> { + fn eq(&self, other: &Index<'_>) -> bool { + match (self, other) { + (Index::Num(a, _), Index::Num(b, _)) => a == b, + (Index::Id(a), Index::Id(b)) => a == b, + _ => false, + } + } +} + +impl Eq for Index<'_> {} + +impl Hash for Index<'_> { + fn hash(&self, hasher: &mut H) { + match self { + Index::Num(a, _) => { + 0u8.hash(hasher); + a.hash(hasher); + } + Index::Id(a) => { + 1u8.hash(hasher); + a.hash(hasher); + } + } + } +} + +/// Parses `(func $foo)` +#[derive(Clone, Debug)] +#[allow(missing_docs)] +pub struct ItemRef<'a, K> { + pub kind: K, + pub idx: Index<'a>, +} + +impl<'a, K: Parse<'a>> Parse<'a> for ItemRef<'a, K> { + fn parse(parser: Parser<'a>) -> Result { + parser.parens(|parser| { + let kind = parser.parse::()?; + let idx = parser.parse()?; + Ok(ItemRef { kind, idx }) + }) + } +} + +impl<'a, K: Peek> Peek for ItemRef<'a, K> { + fn peek(cursor: Cursor<'_>) -> bool { + match cursor.lparen() { + Some(remaining) => K::peek(remaining), + None => false, + } + } + + fn display() -> &'static str { + "an item reference" + } +} + +/// An `@name` annotation in source, currently of the form `@name "foo"` +#[derive(Copy, Clone, PartialEq, Debug)] +pub struct NameAnnotation<'a> { + /// The name specified for the item + pub name: &'a str, +} + +impl<'a> Parse<'a> for NameAnnotation<'a> { + fn parse(parser: Parser<'a>) -> Result { + parser.parse::()?; + let name = parser.parse()?; + Ok(NameAnnotation { name }) + } +} + +impl<'a> Parse<'a> for Option> { + fn parse(parser: Parser<'a>) -> Result { + let _r = parser.register_annotation("name"); + Ok(if parser.peek2::() { + Some(parser.parens(|p| p.parse())?) + } else { + None + }) + } +} + +macro_rules! integers { + ($($i:ident($u:ident))*) => ($( + impl<'a> Parse<'a> for $i { + fn parse(parser: Parser<'a>) -> Result { + Ok(parser.parse::<($i, Span)>()?.0) + } + } + + impl<'a> Parse<'a> for ($i, Span) { + fn parse(parser: Parser<'a>) -> Result { + parser.step(|c| { + if let Some((i, rest)) = c.integer() { + let (s, base) = i.val(); + let val = $i::from_str_radix(s, base) + .or_else(|_| { + $u::from_str_radix(s, base).map(|i| i as $i) + }); + return match val { + Ok(n) => Ok(((n, c.cur_span()), rest)), + Err(_) => Err(c.error(concat!( + "invalid ", + stringify!($i), + " number: constant out of range", + ))), + }; + } + Err(c.error(concat!("expected a ", stringify!($i)))) + }) + } + } + + impl Peek for $i { + fn peek(cursor: Cursor<'_>) -> bool { + cursor.integer().is_some() + } + + fn display() -> &'static str { + stringify!($i) + } + } + )*) +} + +integers! { + u8(u8) u16(u16) u32(u32) u64(u64) + i8(u8) i16(u16) i32(u32) i64(u64) +} + +impl<'a> Parse<'a> for &'a [u8] { + fn parse(parser: Parser<'a>) -> Result { + parser.step(|c| { + if let Some((i, rest)) = c.string() { + return Ok((i, rest)); + } + Err(c.error("expected a string")) + }) + } +} + +impl Peek for &'_ [u8] { + fn peek(cursor: Cursor<'_>) -> bool { + cursor.string().is_some() + } + + fn display() -> &'static str { + "string" + } +} + +impl<'a> Parse<'a> for &'a str { + fn parse(parser: Parser<'a>) -> Result { + str::from_utf8(parser.parse()?).map_err(|_| parser.error("malformed UTF-8 encoding")) + } +} + +impl Parse<'_> for String { + fn parse(parser: Parser<'_>) -> Result { + Ok(<&str>::parse(parser)?.to_string()) + } +} + +impl Peek for &'_ str { + fn peek(cursor: Cursor<'_>) -> bool { + <&[u8]>::peek(cursor) + } + + fn display() -> &'static str { + <&[u8]>::display() + } +} + +macro_rules! float { + ($($name:ident => { + bits: $int:ident, + float: $float:ident, + exponent_bits: $exp_bits:tt, + name: $parse:ident, + })*) => ($( + /// A parsed floating-point type + #[derive(Debug, Copy, Clone)] + pub struct $name { + /// The raw bits that this floating point number represents. + pub bits: $int, + } + + impl<'a> Parse<'a> for $name { + fn parse(parser: Parser<'a>) -> Result { + parser.step(|c| { + let (val, rest) = if let Some((f, rest)) = c.float() { + ($parse(f.val()), rest) + } else if let Some((i, rest)) = c.integer() { + let (s, base) = i.val(); + ( + $parse(&FloatVal::Val { + hex: base == 16, + integral: s.into(), + decimal: None, + exponent: None, + }), + rest, + ) + } else { + return Err(c.error("expected a float")); + }; + match val { + Some(bits) => Ok(($name { bits }, rest)), + None => Err(c.error("invalid float value: constant out of range")), + } + }) + } + } + + fn $parse(val: &FloatVal<'_>) -> Option<$int> { + // Compute a few well-known constants about the float representation + // given the parameters to the macro here. + let width = std::mem::size_of::<$int>() * 8; + let neg_offset = width - 1; + let exp_offset = neg_offset - $exp_bits; + let signif_bits = width - 1 - $exp_bits; + let signif_mask = (1 << exp_offset) - 1; + let bias = (1 << ($exp_bits - 1)) - 1; + + let (hex, integral, decimal, exponent_str) = match val { + // Infinity is when the exponent bits are all set and + // the significand is zero. + FloatVal::Inf { negative } => { + let exp_bits = (1 << $exp_bits) - 1; + let neg_bit = *negative as $int; + return Some( + (neg_bit << neg_offset) | + (exp_bits << exp_offset) + ); + } + + // NaN is when the exponent bits are all set and + // the significand is nonzero. The default of NaN is + // when only the highest bit of the significand is set. + FloatVal::Nan { negative, val } => { + let exp_bits = (1 << $exp_bits) - 1; + let neg_bit = *negative as $int; + let signif = val.unwrap_or(1 << (signif_bits - 1)) as $int; + // If the significand is zero then this is actually infinity + // so we fail to parse it. + if signif & signif_mask == 0 { + return None; + } + return Some( + (neg_bit << neg_offset) | + (exp_bits << exp_offset) | + (signif & signif_mask) + ); + } + + // This is trickier, handle this below + FloatVal::Val { hex, integral, decimal, exponent } => { + (hex, integral, decimal, exponent) + } + }; + + // Rely on Rust's standard library to parse base 10 floats + // correctly. + if !*hex { + let mut s = integral.to_string(); + if let Some(decimal) = decimal { + s.push_str("."); + s.push_str(&decimal); + } + if let Some(exponent) = exponent_str { + s.push_str("e"); + s.push_str(&exponent); + } + let float = s.parse::<$float>().ok()?; + // looks like the `*.wat` format considers infinite overflow to + // be invalid. + if float.is_infinite() { + return None; + } + return Some(float.to_bits()); + } + + // Parsing hex floats is... hard! I don't really know what most of + // this below does. It was copied from Gecko's implementation in + // `WasmTextToBinary.cpp`. Would love comments on this if you have + // them! + let decimal = decimal.as_ref().map(|s| &**s).unwrap_or(""); + let negative = integral.starts_with('-'); + let integral = integral.trim_start_matches('-').trim_start_matches('0'); + + // Do a bunch of work up front to locate the first non-zero digit + // to determine the initial exponent. There's a number of + // adjustments depending on where the digit was found, but the + // general idea here is that I'm not really sure why things are + // calculated the way they are but it should match Gecko. + let decimal_no_leading = decimal.trim_start_matches('0'); + let decimal_iter = if integral.is_empty() { + decimal_no_leading.chars() + } else { + decimal.chars() + }; + let mut digits = integral.chars() + .map(|c| (to_hex(c) as $int, false)) + .chain(decimal_iter.map(|c| (to_hex(c) as $int, true))); + let lead_nonzero_digit = match digits.next() { + Some((c, _)) => c, + // No digits? Must be `+0` or `-0`, being careful to handle the + // sign encoding here. + None if negative => return Some(1 << (width - 1)), + None => return Some(0), + }; + let mut significand = 0 as $int; + let mut exponent = if !integral.is_empty() { + 1 + } else { + -((decimal.len() - decimal_no_leading.len() + 1) as i32) + 1 + }; + let lz = (lead_nonzero_digit as u8).leading_zeros() as i32 - 4; + exponent = exponent.checked_mul(4)?.checked_sub(lz + 1)?; + let mut significand_pos = (width - (4 - (lz as usize))) as isize; + assert!(significand_pos >= 0); + significand |= lead_nonzero_digit << significand_pos; + + // Now that we've got an anchor in the string we parse the remaining + // digits. Again, not entirely sure why everything is the way it is + // here! This is copied frmo gecko. + let mut discarded_extra_nonzero = false; + for (digit, decimal) in digits { + if !decimal { + exponent += 4; + } + if significand_pos > -4 { + significand_pos -= 4; + } + + if significand_pos >= 0 { + significand |= digit << significand_pos; + } else if significand_pos > -4 { + significand |= digit >> (4 - significand_pos); + discarded_extra_nonzero = (digit & !((!0) >> (4 - significand_pos))) != 0; + } else if digit != 0 { + discarded_extra_nonzero = true; + } + } + + exponent = exponent.checked_add(match exponent_str { + Some(s) => s.parse::().ok()?, + None => 0, + })?; + debug_assert!(significand != 0); + + let (encoded_exponent, encoded_significand, discarded_significand) = + if exponent <= -bias { + // Underflow to subnormal or zero. + let shift = exp_offset as i32 + exponent + bias; + if shift == 0 { + (0, 0, significand) + } else if shift < 0 || shift >= width as i32 { + (0, 0, 0) + } else { + ( + 0, + significand >> (width as i32 - shift), + significand << shift, + ) + } + } else if exponent <= bias { + // Normal (non-zero). The significand's leading 1 is encoded + // implicitly. + ( + ((exponent + bias) as $int) << exp_offset, + (significand >> (width - exp_offset - 1)) & signif_mask, + significand << (exp_offset + 1), + ) + } else { + // Overflow to infinity. + ( + ((1 << $exp_bits) - 1) << exp_offset, + 0, + 0, + ) + }; + + let bits = encoded_exponent | encoded_significand; + + // Apply rounding. If this overflows the significand, it carries + // into the exponent bit according to the magic of the IEEE 754 + // encoding. + // + // Or rather, the comment above is what Gecko says so it's copied + // here too. + let msb = 1 << (width - 1); + let bits = bits + + (((discarded_significand & msb != 0) + && ((discarded_significand & !msb != 0) || + discarded_extra_nonzero || + // ties to even + (encoded_significand & 1 != 0))) as $int); + + // Just before we return the bits be sure to handle the sign bit we + // found at the beginning. + let bits = if negative { + bits | (1 << (width - 1)) + } else { + bits + }; + // looks like the `*.wat` format considers infinite overflow to + // be invalid. + if $float::from_bits(bits).is_infinite() { + return None; + } + Some(bits) + } + + )*) +} + +float! { + Float32 => { + bits: u32, + float: f32, + exponent_bits: 8, + name: strtof, + } + Float64 => { + bits: u64, + float: f64, + exponent_bits: 11, + name: strtod, + } +} + +fn to_hex(c: char) -> u8 { + match c { + 'a'..='f' => c as u8 - b'a' + 10, + 'A'..='F' => c as u8 - b'A' + 10, + _ => c as u8 - b'0', + } +} + +/// A convenience type to use with [`Parser::peek`](crate::parser::Parser::peek) +/// to see if the next token is an s-expression. +pub struct LParen { + _priv: (), +} + +impl Peek for LParen { + fn peek(cursor: Cursor<'_>) -> bool { + cursor.lparen().is_some() + } + + fn display() -> &'static str { + "left paren" + } +} + +#[cfg(test)] +mod tests { + #[test] + fn hex_strtof() { + macro_rules! f { + ($a:tt) => (f!(@mk $a, None, None)); + ($a:tt p $e:tt) => (f!(@mk $a, None, Some($e.into()))); + ($a:tt . $b:tt) => (f!(@mk $a, Some($b.into()), None)); + ($a:tt . $b:tt p $e:tt) => (f!(@mk $a, Some($b.into()), Some($e.into()))); + (@mk $a:tt, $b:expr, $e:expr) => (crate::lexer::FloatVal::Val { + hex: true, + integral: $a.into(), + decimal: $b, + exponent: $e + }); + } + assert_eq!(super::strtof(&f!("0")), Some(0)); + assert_eq!(super::strtof(&f!("0" . "0")), Some(0)); + assert_eq!(super::strtof(&f!("0" . "0" p "2354")), Some(0)); + assert_eq!(super::strtof(&f!("-0")), Some(1 << 31)); + assert_eq!(super::strtof(&f!("f32")), Some(0x45732000)); + assert_eq!(super::strtof(&f!("0" . "f32")), Some(0x3f732000)); + assert_eq!(super::strtof(&f!("1" . "2")), Some(0x3f900000)); + assert_eq!( + super::strtof(&f!("0" . "00000100000000000" p "-126")), + Some(0) + ); + assert_eq!( + super::strtof(&f!("1" . "fffff4" p "-106")), + Some(0x0afffffa) + ); + assert_eq!(super::strtof(&f!("fffff98" p "-133")), Some(0x0afffffa)); + assert_eq!(super::strtof(&f!("0" . "081" p "023")), Some(0x48810000)); + assert_eq!( + super::strtof(&f!("1" . "00000100000000000" p "-50")), + Some(0x26800000) + ); + } +} diff --git a/crates/wastlhw/src/wast.rs b/crates/wastlhw/src/wast.rs new file mode 100644 index 000000000..ec589e59d --- /dev/null +++ b/crates/wastlhw/src/wast.rs @@ -0,0 +1,365 @@ +use crate::component::WastVal; +use crate::core::{WastArgCore, WastRetCore}; +use crate::kw; +use crate::parser::{self, Cursor, Parse, ParseBuffer, Parser, Peek, Result}; +use crate::token::{Id, Span}; +use crate::{Error, Wat}; + +/// A parsed representation of a `*.wast` file. +/// +/// WAST files are not officially specified but are used in the official test +/// suite to write official spec tests for wasm. This type represents a parsed +/// `*.wast` file which parses a list of directives in a file. +#[derive(Debug)] +pub struct Wast<'a> { + #[allow(missing_docs)] + pub directives: Vec>, +} + +impl<'a> Parse<'a> for Wast<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut directives = Vec::new(); + + // If it looks like a directive token is in the stream then we parse a + // bunch of directives, otherwise assume this is an inline module. + if parser.peek2::() { + while !parser.is_empty() { + directives.push(parser.parens(|p| p.parse())?); + } + } else { + let module = parser.parse::()?; + directives.push(WastDirective::Wat(QuoteWat::Wat(module))); + } + Ok(Wast { directives }) + } +} + +struct WastDirectiveToken; + +impl Peek for WastDirectiveToken { + fn peek(cursor: Cursor<'_>) -> bool { + let kw = match cursor.keyword() { + Some((kw, _)) => kw, + None => return false, + }; + kw.starts_with("assert_") + || kw == "module" + || kw == "component" + || kw == "register" + || kw == "invoke" + } + + fn display() -> &'static str { + unimplemented!() + } +} + +/// The different kinds of directives found in a `*.wast` file. +/// +/// It's not entirely clear to me what all of these are per se, but they're only +/// really interesting to test harnesses mostly. +#[allow(missing_docs)] +#[derive(Debug)] +pub enum WastDirective<'a> { + Wat(QuoteWat<'a>), + AssertMalformed { + span: Span, + module: QuoteWat<'a>, + message: &'a str, + }, + AssertInvalid { + span: Span, + module: QuoteWat<'a>, + message: &'a str, + }, + Register { + span: Span, + name: &'a str, + module: Option>, + }, + Invoke(WastInvoke<'a>), + AssertTrap { + span: Span, + exec: WastExecute<'a>, + message: &'a str, + }, + AssertReturn { + span: Span, + exec: WastExecute<'a>, + results: Vec>, + }, + AssertExhaustion { + span: Span, + call: WastInvoke<'a>, + message: &'a str, + }, + AssertUnlinkable { + span: Span, + module: Wat<'a>, + message: &'a str, + }, + AssertException { + span: Span, + exec: WastExecute<'a>, + }, +} + +impl WastDirective<'_> { + /// Returns the location in the source that this directive was defined at + pub fn span(&self) -> Span { + match self { + WastDirective::Wat(QuoteWat::Wat(Wat::Module(m))) => m.span, + WastDirective::Wat(QuoteWat::Wat(Wat::Component(c))) => c.span, + WastDirective::Wat(QuoteWat::QuoteModule(span, _)) => *span, + WastDirective::Wat(QuoteWat::QuoteComponent(span, _)) => *span, + WastDirective::AssertMalformed { span, .. } + | WastDirective::Register { span, .. } + | WastDirective::AssertTrap { span, .. } + | WastDirective::AssertReturn { span, .. } + | WastDirective::AssertExhaustion { span, .. } + | WastDirective::AssertUnlinkable { span, .. } + | WastDirective::AssertInvalid { span, .. } + | WastDirective::AssertException { span, .. } => *span, + WastDirective::Invoke(i) => i.span, + } + } +} + +impl<'a> Parse<'a> for WastDirective<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() || l.peek::() { + Ok(WastDirective::Wat(parser.parse()?)) + } else if l.peek::() { + let span = parser.parse::()?.0; + Ok(WastDirective::AssertMalformed { + span, + module: parser.parens(|p| p.parse())?, + message: parser.parse()?, + }) + } else if l.peek::() { + let span = parser.parse::()?.0; + Ok(WastDirective::AssertInvalid { + span, + module: parser.parens(|p| p.parse())?, + message: parser.parse()?, + }) + } else if l.peek::() { + let span = parser.parse::()?.0; + Ok(WastDirective::Register { + span, + name: parser.parse()?, + module: parser.parse()?, + }) + } else if l.peek::() { + Ok(WastDirective::Invoke(parser.parse()?)) + } else if l.peek::() { + let span = parser.parse::()?.0; + Ok(WastDirective::AssertTrap { + span, + exec: parser.parens(|p| p.parse())?, + message: parser.parse()?, + }) + } else if l.peek::() { + let span = parser.parse::()?.0; + let exec = parser.parens(|p| p.parse())?; + let mut results = Vec::new(); + while !parser.is_empty() { + results.push(parser.parens(|p| p.parse())?); + } + Ok(WastDirective::AssertReturn { + span, + exec, + results, + }) + } else if l.peek::() { + let span = parser.parse::()?.0; + Ok(WastDirective::AssertExhaustion { + span, + call: parser.parens(|p| p.parse())?, + message: parser.parse()?, + }) + } else if l.peek::() { + let span = parser.parse::()?.0; + Ok(WastDirective::AssertUnlinkable { + span, + module: parser.parens(parse_wat)?, + message: parser.parse()?, + }) + } else if l.peek::() { + let span = parser.parse::()?.0; + Ok(WastDirective::AssertException { + span, + exec: parser.parens(|p| p.parse())?, + }) + } else { + Err(l.error()) + } + } +} + +#[allow(missing_docs)] +#[derive(Debug)] +pub enum WastExecute<'a> { + Invoke(WastInvoke<'a>), + Wat(Wat<'a>), + Get { + module: Option>, + global: &'a str, + }, +} + +impl<'a> Parse<'a> for WastExecute<'a> { + fn parse(parser: Parser<'a>) -> Result { + let mut l = parser.lookahead1(); + if l.peek::() { + Ok(WastExecute::Invoke(parser.parse()?)) + } else if l.peek::() || l.peek::() { + Ok(WastExecute::Wat(parse_wat(parser)?)) + } else if l.peek::() { + parser.parse::()?; + Ok(WastExecute::Get { + module: parser.parse()?, + global: parser.parse()?, + }) + } else { + Err(l.error()) + } + } +} + +fn parse_wat(parser: Parser) -> Result { + // Note that this doesn't use `Parse for Wat` since the `parser` provided + // has already peeled back the first layer of parentheses while `Parse for + // Wat` expects to be the top layer which means it also tries to peel off + // the parens. Instead we can skip the sugar that `Wat` has for simply a + // list of fields (no `(module ...)` container) and just parse the `Module` + // itself. + if parser.peek::() { + Ok(Wat::Component(parser.parse()?)) + } else { + Ok(Wat::Module(parser.parse()?)) + } +} + +#[allow(missing_docs)] +#[derive(Debug)] +pub struct WastInvoke<'a> { + pub span: Span, + pub module: Option>, + pub name: &'a str, + pub args: Vec>, +} + +impl<'a> Parse<'a> for WastInvoke<'a> { + fn parse(parser: Parser<'a>) -> Result { + let span = parser.parse::()?.0; + let module = parser.parse()?; + let name = parser.parse()?; + let mut args = Vec::new(); + while !parser.is_empty() { + args.push(parser.parens(|p| p.parse())?); + } + Ok(WastInvoke { + span, + module, + name, + args, + }) + } +} + +#[allow(missing_docs)] +#[derive(Debug)] +pub enum QuoteWat<'a> { + Wat(Wat<'a>), + QuoteModule(Span, Vec<(Span, &'a [u8])>), + QuoteComponent(Span, Vec<(Span, &'a [u8])>), +} + +impl QuoteWat<'_> { + /// Encodes this module to bytes, either by encoding the module directly or + /// parsing the contents and then encoding it. + pub fn encode(&mut self) -> Result, Error> { + let (source, prefix) = match self { + QuoteWat::Wat(m) => return m.encode(), + QuoteWat::QuoteModule(_, source) => (source, None), + QuoteWat::QuoteComponent(_, source) => (source, Some("(component")), + }; + let mut ret = String::new(); + for (span, src) in source { + match std::str::from_utf8(src) { + Ok(s) => ret.push_str(s), + Err(_) => { + return Err(Error::new(*span, "malformed UTF-8 encoding".to_string())); + } + } + ret.push(' '); + } + if let Some(prefix) = prefix { + ret.insert_str(0, prefix); + ret.push(')'); + } + let buf = ParseBuffer::new(&ret)?; + let mut wat = parser::parse::>(&buf)?; + wat.encode() + } +} + +impl<'a> Parse<'a> for QuoteWat<'a> { + fn parse(parser: Parser<'a>) -> Result { + if parser.peek2::() { + let ctor = if parser.peek::() { + parser.parse::()?; + QuoteWat::QuoteComponent + } else { + parser.parse::()?; + QuoteWat::QuoteModule + }; + let span = parser.parse::()?.0; + let mut src = Vec::new(); + while !parser.is_empty() { + let span = parser.cur_span(); + let string = parser.parse()?; + src.push((span, string)); + } + Ok(ctor(span, src)) + } else { + Ok(QuoteWat::Wat(parse_wat(parser)?)) + } + } +} + +#[derive(Debug)] +#[allow(missing_docs)] +pub enum WastArg<'a> { + Core(WastArgCore<'a>), + Component(WastVal<'a>), +} + +impl<'a> Parse<'a> for WastArg<'a> { + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::>() { + Ok(WastArg::Core(parser.parse()?)) + } else { + Ok(WastArg::Component(parser.parse()?)) + } + } +} + +#[derive(Debug)] +#[allow(missing_docs)] +pub enum WastRet<'a> { + Core(WastRetCore<'a>), + Component(WastVal<'a>), +} + +impl<'a> Parse<'a> for WastRet<'a> { + fn parse(parser: Parser<'a>) -> Result { + if parser.peek::>() { + Ok(WastRet::Core(parser.parse()?)) + } else { + Ok(WastRet::Component(parser.parse()?)) + } + } +} diff --git a/crates/wastlhw/src/wat.rs b/crates/wastlhw/src/wat.rs new file mode 100644 index 000000000..631bc3d0e --- /dev/null +++ b/crates/wastlhw/src/wat.rs @@ -0,0 +1,60 @@ +use crate::component::Component; +use crate::core::{Module, ModuleField, ModuleKind}; +use crate::kw; +use crate::parser::{Parse, Parser, Result}; +use crate::token::Span; + +/// A `*.wat` file parser, or a parser for one parenthesized module. +/// +/// This is the top-level type which you'll frequently parse when working with +/// this crate. A `*.wat` file is either one `module` s-expression or a sequence +/// of s-expressions that are module fields. +#[derive(Debug)] +#[allow(missing_docs)] +pub enum Wat<'a> { + Module(Module<'a>), + Component(Component<'a>), +} + +impl Wat<'_> { + fn validate(&self, parser: Parser<'_>) -> Result<()> { + match self { + Wat::Module(m) => m.validate(parser), + Wat::Component(c) => c.validate(parser), + } + } + + /// Encodes this `Wat` to binary form. This calls either [`Module::encode`] + /// or [`Component::encode`]. + pub fn encode(&mut self) -> std::result::Result, crate::Error> { + match self { + Wat::Module(m) => m.encode(), + Wat::Component(c) => c.encode(), + } + } +} + +impl<'a> Parse<'a> for Wat<'a> { + fn parse(parser: Parser<'a>) -> Result { + if !parser.has_meaningful_tokens() { + return Err(parser.error("expected at least one module field")); + } + + let _r = parser.register_annotation("custom"); + let wat = if parser.peek2::() { + Wat::Module(parser.parens(|parser| parser.parse())?) + } else if parser.peek2::() { + Wat::Component(parser.parens(|parser| parser.parse())?) + } else { + let fields = ModuleField::parse_remaining(parser)?; + Wat::Module(Module { + span: Span { offset: 0 }, + id: None, + name: None, + kind: ModuleKind::Text(fields), + }) + }; + wat.validate(parser)?; + Ok(wat) + } +} diff --git a/crates/wastlhw/tests/.gitattributes b/crates/wastlhw/tests/.gitattributes new file mode 100644 index 000000000..75de48a52 --- /dev/null +++ b/crates/wastlhw/tests/.gitattributes @@ -0,0 +1 @@ +parse-fail/newline-in-string.wat text eol=lf diff --git a/crates/wastlhw/tests/.gitignore b/crates/wastlhw/tests/.gitignore new file mode 100644 index 000000000..265315a86 --- /dev/null +++ b/crates/wastlhw/tests/.gitignore @@ -0,0 +1 @@ +!*.wat diff --git a/crates/wastlhw/tests/annotations.rs b/crates/wastlhw/tests/annotations.rs new file mode 100644 index 000000000..b5ec89470 --- /dev/null +++ b/crates/wastlhw/tests/annotations.rs @@ -0,0 +1,197 @@ +use wasmparser::*; + +#[test] +fn name_annotations() -> anyhow::Result<()> { + assert_module_name("foo", r#"(module $foo)"#)?; + assert_module_name("foo", r#"(module (@name "foo"))"#)?; + assert_module_name("foo", r#"(module $bar (@name "foo"))"#)?; + assert_module_name("foo bar", r#"(module $bar (@name "foo bar"))"#)?; + Ok(()) +} + +fn assert_module_name(name: &str, wat: &str) -> anyhow::Result<()> { + let wasm = wat::parse_str(wat)?; + let mut found = false; + for s in get_name_section(&wasm)? { + match s? { + Name::Module(n) => { + assert_eq!(n.get_name()?, name); + found = true; + } + _ => {} + } + } + assert!(found); + Ok(()) +} + +#[test] +fn func_annotations() -> anyhow::Result<()> { + assert_func_name("foo", r#"(module (func $foo))"#)?; + assert_func_name("foo", r#"(module (func (@name "foo")))"#)?; + assert_func_name("foo", r#"(module (func $bar (@name "foo")))"#)?; + assert_func_name("foo bar", r#"(module (func $bar (@name "foo bar")))"#)?; + Ok(()) +} + +fn assert_func_name(name: &str, wat: &str) -> anyhow::Result<()> { + let wasm = wat::parse_str(wat)?; + let mut found = false; + for s in get_name_section(&wasm)? { + match s? { + Name::Function(n) => { + let mut map = n.get_map()?; + let naming = map.read()?; + assert_eq!(naming.index, 0); + assert_eq!(naming.name, name); + found = true; + } + _ => {} + } + } + assert!(found); + Ok(()) +} + +#[test] +fn local_annotations() -> anyhow::Result<()> { + assert_local_name("foo", r#"(module (func (param $foo i32)))"#)?; + assert_local_name("foo", r#"(module (func (local $foo i32)))"#)?; + assert_local_name("foo", r#"(module (func (param (@name "foo") i32)))"#)?; + assert_local_name("foo", r#"(module (func (local (@name "foo") i32)))"#)?; + assert_local_name("foo", r#"(module (func (param $bar (@name "foo") i32)))"#)?; + assert_local_name("foo", r#"(module (func (local $bar (@name "foo") i32)))"#)?; + assert_local_name( + "foo bar", + r#"(module (func (param $bar (@name "foo bar") i32)))"#, + )?; + assert_local_name( + "foo bar", + r#"(module (func (local $bar (@name "foo bar") i32)))"#, + )?; + Ok(()) +} + +fn assert_local_name(name: &str, wat: &str) -> anyhow::Result<()> { + let wasm = wat::parse_str(wat)?; + let mut found = false; + for s in get_name_section(&wasm)? { + match s? { + Name::Local(n) => { + let mut reader = n.get_indirect_map()?; + let section = reader.read()?; + let mut map = section.get_map()?; + let naming = map.read()?; + assert_eq!(naming.index, 0); + assert_eq!(naming.name, name); + found = true; + } + _ => {} + } + } + assert!(found); + Ok(()) +} + +fn get_name_section(wasm: &[u8]) -> anyhow::Result> { + for payload in Parser::new(0).parse_all(&wasm) { + if let Payload::CustomSection(c) = payload? { + if c.name() == "name" { + return Ok(NameSectionReader::new(c.data(), c.data_offset())?); + } + } + } + panic!("no name section found"); +} + +#[test] +fn custom_section_order() -> anyhow::Result<()> { + let bytes = wat::parse_str( + r#" + (module + (@custom "A" "aaa") + (type (func)) + (@custom "B" (after func) "bbb") + (@custom "C" (before func) "ccc") + (@custom "D" (after last) "ddd") + (table 10 funcref) + (func (type 0)) + (@custom "E" (after import) "eee") + (@custom "F" (before type) "fff") + (@custom "G" (after data) "ggg") + (@custom "H" (after code) "hhh") + (@custom "I" (after func) "iii") + (@custom "J" (before func) "jjj") + (@custom "K" (before first) "kkk") + ) + "#, + )?; + macro_rules! assert_matches { + ($a:expr, $b:pat $(if $cond:expr)? $(,)?) => { + match &$a { + $b $(if $cond)? => {} + a => panic!("`{:?}` doesn't match `{}`", a, stringify!($b)), + } + }; + } + let wasm = Parser::new(0) + .parse_all(&bytes) + .collect::>>()?; + assert_matches!(wasm[0], Payload::Version { .. }); + assert_matches!( + wasm[1], + Payload::CustomSection(c) if c.name() == "K" + ); + assert_matches!( + wasm[2], + Payload::CustomSection(c) if c.name() == "F" + ); + assert_matches!(wasm[3], Payload::TypeSection(_)); + assert_matches!( + wasm[4], + Payload::CustomSection(c) if c.name() == "E" + ); + assert_matches!( + wasm[5], + Payload::CustomSection(c) if c.name() == "C" + ); + assert_matches!( + wasm[6], + Payload::CustomSection(c) if c.name() == "J" + ); + assert_matches!(wasm[7], Payload::FunctionSection(_)); + assert_matches!( + wasm[8], + Payload::CustomSection(c) if c.name() == "B" + ); + assert_matches!( + wasm[9], + Payload::CustomSection(c) if c.name() == "I" + ); + assert_matches!(wasm[10], Payload::TableSection(_)); + assert_matches!(wasm[11], Payload::CodeSectionStart { .. }); + assert_matches!(wasm[12], Payload::CodeSectionEntry { .. }); + assert_matches!( + wasm[13], + Payload::CustomSection(c) if c.name() == "H" + ); + assert_matches!( + wasm[14], + Payload::CustomSection(c) if c.name() == "G" + ); + assert_matches!( + wasm[15], + Payload::CustomSection(c) if c.name() == "A" + ); + assert_matches!( + wasm[16], + Payload::CustomSection(c) if c.name() == "D" + ); + + match &wasm[17] { + Payload::End(x) if *x == bytes.len() => {} + p => panic!("`{:?}` doesn't match expected length of {}", p, bytes.len()), + } + + Ok(()) +} diff --git a/crates/wastlhw/tests/comments.rs b/crates/wastlhw/tests/comments.rs new file mode 100644 index 000000000..ae5b310fe --- /dev/null +++ b/crates/wastlhw/tests/comments.rs @@ -0,0 +1,76 @@ +use wastlhw::parser::{self, Parse, ParseBuffer, Parser, Result}; + +pub struct Comments<'a> { + comments: Vec<&'a str>, +} + +impl<'a> Parse<'a> for Comments<'a> { + fn parse(parser: Parser<'a>) -> Result> { + let comments = parser.step(|mut cursor| { + let mut comments = Vec::new(); + loop { + let (comment, c) = match cursor.comment() { + Some(pair) => pair, + None => break, + }; + cursor = c; + comments.push(if comment.starts_with(";;") { + &comment[2..] + } else { + &comment[2..comment.len() - 2] + }); + } + Ok((comments, cursor)) + })?; + Ok(Comments { comments }) + } +} + +pub struct Documented<'a, T> { + comments: Comments<'a>, + item: T, +} + +impl<'a, T: Parse<'a>> Parse<'a> for Documented<'a, T> { + fn parse(parser: Parser<'a>) -> Result { + let comments = parser.parse()?; + let item = parser.parens(T::parse)?; + Ok(Documented { comments, item }) + } +} + +#[test] +fn parse_comments() -> anyhow::Result<()> { + let buf = ParseBuffer::new( + r#" +;; hello +(; again ;) +(module) + "#, + )?; + + let d: Documented = parser::parse(&buf)?; + assert_eq!(d.comments.comments, vec![" hello", " again "]); + drop(d.item); + + let buf = ParseBuffer::new( + r#" +;; this +(; is +on +multiple;) + + +;; lines +(func) + "#, + )?; + + let d: Documented = parser::parse(&buf)?; + assert_eq!( + d.comments.comments, + vec![" this", " is\non\nmultiple", " lines"] + ); + drop(d.item); + Ok(()) +} diff --git a/crates/wastlhw/tests/parse-fail.rs b/crates/wastlhw/tests/parse-fail.rs new file mode 100644 index 000000000..3ae1817a4 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail.rs @@ -0,0 +1,98 @@ +//! A test suite to parse everything in `parse-fail` and assert that it matches +//! the `*.err` file it generates. +//! +//! Use `BLESS=1` in the environment to auto-update `*.err` files. Be sure to +//! look at the diff! + +use rayon::prelude::*; +use std::env; +use std::path::{Path, PathBuf}; + +fn main() { + let mut tests = Vec::new(); + find_tests("tests/parse-fail".as_ref(), &mut tests); + let filter = std::env::args().nth(1); + + let bless = env::var("BLESS").is_ok(); + let tests = tests + .iter() + .filter(|test| { + if let Some(filter) = &filter { + if let Some(s) = test.file_name().and_then(|s| s.to_str()) { + if !s.contains(filter) { + return false; + } + } + } + true + }) + .collect::>(); + + println!("running {} tests\n", tests.len()); + + let errors = tests + .par_iter() + .filter_map(|test| run_test(test, bless).err()) + .collect::>(); + + if !errors.is_empty() { + for msg in errors.iter() { + eprintln!("{}", msg); + } + + panic!("{} tests failed", errors.len()) + } + + println!("test result: ok. {} passed\n", tests.len()); +} + +fn run_test(test: &Path, bless: bool) -> anyhow::Result<()> { + let err = match wat::parse_file(test) { + Ok(_) => anyhow::bail!("{} parsed successfully", test.display()), + Err(e) => e.to_string() + "\n", + }; + let assert = test.with_extension("wat.err"); + if bless { + std::fs::write(assert, err.to_string())?; + return Ok(()); + } + + // Ignore CRLF line ending and force always `\n` + let assert = std::fs::read_to_string(assert) + .unwrap_or(String::new()) + .replace("\r\n", "\n"); + + // Compare normalize verisons which handles weirdness like path differences + if normalize(&assert) == normalize(&err) { + return Ok(()); + } + + anyhow::bail!( + "errors did not match:\n\nexpected:\n\t{}\nactual:\n\t{}\n", + tab(&assert), + tab(&err), + ); + + fn normalize(s: &str) -> String { + s.replace("\\", "/") + } + + fn tab(s: &str) -> String { + s.replace("\n", "\n\t") + } +} + +fn find_tests(path: &Path, tests: &mut Vec) { + for f in path.read_dir().unwrap() { + let f = f.unwrap(); + if f.file_type().unwrap().is_dir() { + find_tests(&f.path(), tests); + continue; + } + match f.path().extension().and_then(|s| s.to_str()) { + Some("wat") => {} + _ => continue, + } + tests.push(f.path()); + } +} diff --git a/crates/wastlhw/tests/parse-fail/bad-index.wat b/crates/wastlhw/tests/parse-fail/bad-index.wat new file mode 100644 index 000000000..34262539a --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/bad-index.wat @@ -0,0 +1 @@ +(func br_on_null $s) diff --git a/crates/wastlhw/tests/parse-fail/bad-index.wat.err b/crates/wastlhw/tests/parse-fail/bad-index.wat.err new file mode 100644 index 000000000..717d46017 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/bad-index.wat.err @@ -0,0 +1,5 @@ +failed to find label named `$s` + --> tests/parse-fail/bad-index.wat:1:18 + | + 1 | (func br_on_null $s) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/bad-name.wat b/crates/wastlhw/tests/parse-fail/bad-name.wat new file mode 100644 index 000000000..ce74a7d1c --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/bad-name.wat @@ -0,0 +1 @@ +(module (@name)) diff --git a/crates/wastlhw/tests/parse-fail/bad-name.wat.err b/crates/wastlhw/tests/parse-fail/bad-name.wat.err new file mode 100644 index 000000000..f20e2039b --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/bad-name.wat.err @@ -0,0 +1,5 @@ +expected a string + --> tests/parse-fail/bad-name.wat:1:15 + | + 1 | (module (@name)) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/bad-name2.wat b/crates/wastlhw/tests/parse-fail/bad-name2.wat new file mode 100644 index 000000000..7786f25ac --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/bad-name2.wat @@ -0,0 +1,2 @@ +(module (@name 2)) + diff --git a/crates/wastlhw/tests/parse-fail/bad-name2.wat.err b/crates/wastlhw/tests/parse-fail/bad-name2.wat.err new file mode 100644 index 000000000..f937e98bf --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/bad-name2.wat.err @@ -0,0 +1,5 @@ +expected a string + --> tests/parse-fail/bad-name2.wat:1:16 + | + 1 | (module (@name 2)) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/bad-name3.wat b/crates/wastlhw/tests/parse-fail/bad-name3.wat new file mode 100644 index 000000000..02c8c5de0 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/bad-name3.wat @@ -0,0 +1 @@ +(module (func (@name 2))) diff --git a/crates/wastlhw/tests/parse-fail/bad-name3.wat.err b/crates/wastlhw/tests/parse-fail/bad-name3.wat.err new file mode 100644 index 000000000..43c57e759 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/bad-name3.wat.err @@ -0,0 +1,5 @@ +expected a string + --> tests/parse-fail/bad-name3.wat:1:22 + | + 1 | (module (func (@name 2))) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/block1.wat b/crates/wastlhw/tests/parse-fail/block1.wat new file mode 100644 index 000000000..2c1d238e1 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/block1.wat @@ -0,0 +1 @@ +(; diff --git a/crates/wastlhw/tests/parse-fail/block1.wat.err b/crates/wastlhw/tests/parse-fail/block1.wat.err new file mode 100644 index 000000000..8544f334a --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/block1.wat.err @@ -0,0 +1,5 @@ +unterminated block comment + --> tests/parse-fail/block1.wat:1:1 + | + 1 | (; + | ^ diff --git a/crates/wastlhw/tests/parse-fail/block2.wat b/crates/wastlhw/tests/parse-fail/block2.wat new file mode 100644 index 000000000..5bfa511a1 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/block2.wat @@ -0,0 +1 @@ +(; (;;) diff --git a/crates/wastlhw/tests/parse-fail/block2.wat.err b/crates/wastlhw/tests/parse-fail/block2.wat.err new file mode 100644 index 000000000..fdf1ce27a --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/block2.wat.err @@ -0,0 +1,5 @@ +unterminated block comment + --> tests/parse-fail/block2.wat:1:1 + | + 1 | (; (;;) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/block3.wat b/crates/wastlhw/tests/parse-fail/block3.wat new file mode 100644 index 000000000..beab65b9a --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/block3.wat @@ -0,0 +1 @@ +(; ; diff --git a/crates/wastlhw/tests/parse-fail/block3.wat.err b/crates/wastlhw/tests/parse-fail/block3.wat.err new file mode 100644 index 000000000..d12a53411 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/block3.wat.err @@ -0,0 +1,5 @@ +unterminated block comment + --> tests/parse-fail/block3.wat:1:1 + | + 1 | (; ; + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment0.wat b/crates/wastlhw/tests/parse-fail/confusing-block-comment0.wat new file mode 100644 index 000000000..d336f4ce9 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment0.wat @@ -0,0 +1 @@ +(module) (; ‪ ;) diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment0.wat.err b/crates/wastlhw/tests/parse-fail/confusing-block-comment0.wat.err new file mode 100644 index 000000000..964cb84eb --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment0.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{202a}' + --> tests/parse-fail/confusing-block-comment0.wat:1:13 + | + 1 | (module) (; ;) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment1.wat b/crates/wastlhw/tests/parse-fail/confusing-block-comment1.wat new file mode 100644 index 000000000..29d83f46d --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment1.wat @@ -0,0 +1 @@ +(module) (; ‫ ;) diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment1.wat.err b/crates/wastlhw/tests/parse-fail/confusing-block-comment1.wat.err new file mode 100644 index 000000000..5f6a8670e --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment1.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{202b}' + --> tests/parse-fail/confusing-block-comment1.wat:1:13 + | + 1 | (module) (; ;) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment2.wat b/crates/wastlhw/tests/parse-fail/confusing-block-comment2.wat new file mode 100644 index 000000000..ee0d705a8 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment2.wat @@ -0,0 +1 @@ +(module) (; ‭ ;) diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment2.wat.err b/crates/wastlhw/tests/parse-fail/confusing-block-comment2.wat.err new file mode 100644 index 000000000..08f77e424 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment2.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{202d}' + --> tests/parse-fail/confusing-block-comment2.wat:1:13 + | + 1 | (module) (; ;) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment3.wat b/crates/wastlhw/tests/parse-fail/confusing-block-comment3.wat new file mode 100644 index 000000000..cd849f21b --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment3.wat @@ -0,0 +1 @@ +(module) (; ‮ ;) diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment3.wat.err b/crates/wastlhw/tests/parse-fail/confusing-block-comment3.wat.err new file mode 100644 index 000000000..5da080d3b --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment3.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{202e}' + --> tests/parse-fail/confusing-block-comment3.wat:1:13 + | + 1 | (module) (; ;) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment4.wat b/crates/wastlhw/tests/parse-fail/confusing-block-comment4.wat new file mode 100644 index 000000000..6c64d834a --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment4.wat @@ -0,0 +1 @@ +(module) (; ⁦ ;) diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment4.wat.err b/crates/wastlhw/tests/parse-fail/confusing-block-comment4.wat.err new file mode 100644 index 000000000..3f3aacf9f --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment4.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{2066}' + --> tests/parse-fail/confusing-block-comment4.wat:1:13 + | + 1 | (module) (; ;) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment5.wat b/crates/wastlhw/tests/parse-fail/confusing-block-comment5.wat new file mode 100644 index 000000000..f35482159 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment5.wat @@ -0,0 +1 @@ +(module) (; ⁧ ;) diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment5.wat.err b/crates/wastlhw/tests/parse-fail/confusing-block-comment5.wat.err new file mode 100644 index 000000000..547c85961 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment5.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{2067}' + --> tests/parse-fail/confusing-block-comment5.wat:1:13 + | + 1 | (module) (; ;) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment6.wat b/crates/wastlhw/tests/parse-fail/confusing-block-comment6.wat new file mode 100644 index 000000000..c394085a6 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment6.wat @@ -0,0 +1 @@ +(module) (; ⁨ ;) diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment6.wat.err b/crates/wastlhw/tests/parse-fail/confusing-block-comment6.wat.err new file mode 100644 index 000000000..0cbc9d70b --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment6.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{2068}' + --> tests/parse-fail/confusing-block-comment6.wat:1:13 + | + 1 | (module) (; ;) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment7.wat b/crates/wastlhw/tests/parse-fail/confusing-block-comment7.wat new file mode 100644 index 000000000..2977dcf18 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment7.wat @@ -0,0 +1 @@ +(module) (;  ;) diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment7.wat.err b/crates/wastlhw/tests/parse-fail/confusing-block-comment7.wat.err new file mode 100644 index 000000000..524257441 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment7.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{206c}' + --> tests/parse-fail/confusing-block-comment7.wat:1:13 + | + 1 | (module) (; ;) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment8.wat b/crates/wastlhw/tests/parse-fail/confusing-block-comment8.wat new file mode 100644 index 000000000..3d44c0148 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment8.wat @@ -0,0 +1 @@ +(module) (; ⁩ ;) diff --git a/crates/wastlhw/tests/parse-fail/confusing-block-comment8.wat.err b/crates/wastlhw/tests/parse-fail/confusing-block-comment8.wat.err new file mode 100644 index 000000000..fe89af152 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-block-comment8.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{2069}' + --> tests/parse-fail/confusing-block-comment8.wat:1:13 + | + 1 | (module) (; ;) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment0.wat b/crates/wastlhw/tests/parse-fail/confusing-line-comment0.wat new file mode 100644 index 000000000..72e8caa7d --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment0.wat @@ -0,0 +1 @@ +(module) ;; ‪ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment0.wat.err b/crates/wastlhw/tests/parse-fail/confusing-line-comment0.wat.err new file mode 100644 index 000000000..1d665d7f7 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment0.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{202a}' + --> tests/parse-fail/confusing-line-comment0.wat:1:13 + | + 1 | (module) ;; + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment1.wat b/crates/wastlhw/tests/parse-fail/confusing-line-comment1.wat new file mode 100644 index 000000000..af7e5e634 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment1.wat @@ -0,0 +1 @@ +(module) ;; ‫ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment1.wat.err b/crates/wastlhw/tests/parse-fail/confusing-line-comment1.wat.err new file mode 100644 index 000000000..e614bad73 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment1.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{202b}' + --> tests/parse-fail/confusing-line-comment1.wat:1:13 + | + 1 | (module) ;; + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment2.wat b/crates/wastlhw/tests/parse-fail/confusing-line-comment2.wat new file mode 100644 index 000000000..ac67c0e6b --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment2.wat @@ -0,0 +1 @@ +(module) ;; ‭ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment2.wat.err b/crates/wastlhw/tests/parse-fail/confusing-line-comment2.wat.err new file mode 100644 index 000000000..e5f1fda5e --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment2.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{202d}' + --> tests/parse-fail/confusing-line-comment2.wat:1:13 + | + 1 | (module) ;; + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment3.wat b/crates/wastlhw/tests/parse-fail/confusing-line-comment3.wat new file mode 100644 index 000000000..57e38b223 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment3.wat @@ -0,0 +1 @@ +(module) ;; ‮ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment3.wat.err b/crates/wastlhw/tests/parse-fail/confusing-line-comment3.wat.err new file mode 100644 index 000000000..787c01976 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment3.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{202e}' + --> tests/parse-fail/confusing-line-comment3.wat:1:13 + | + 1 | (module) ;; + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment4.wat b/crates/wastlhw/tests/parse-fail/confusing-line-comment4.wat new file mode 100644 index 000000000..d066d64be --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment4.wat @@ -0,0 +1 @@ +(module) ;; ⁦ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment4.wat.err b/crates/wastlhw/tests/parse-fail/confusing-line-comment4.wat.err new file mode 100644 index 000000000..9c5951c74 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment4.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{2066}' + --> tests/parse-fail/confusing-line-comment4.wat:1:13 + | + 1 | (module) ;; + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment5.wat b/crates/wastlhw/tests/parse-fail/confusing-line-comment5.wat new file mode 100644 index 000000000..02ca3e233 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment5.wat @@ -0,0 +1 @@ +(module) ;; ⁧ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment5.wat.err b/crates/wastlhw/tests/parse-fail/confusing-line-comment5.wat.err new file mode 100644 index 000000000..f0d96fdba --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment5.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{2067}' + --> tests/parse-fail/confusing-line-comment5.wat:1:13 + | + 1 | (module) ;; + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment6.wat b/crates/wastlhw/tests/parse-fail/confusing-line-comment6.wat new file mode 100644 index 000000000..7d5f48f78 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment6.wat @@ -0,0 +1 @@ +(module) ;; ⁨ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment6.wat.err b/crates/wastlhw/tests/parse-fail/confusing-line-comment6.wat.err new file mode 100644 index 000000000..9e92eeb69 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment6.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{2068}' + --> tests/parse-fail/confusing-line-comment6.wat:1:13 + | + 1 | (module) ;; + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment7.wat b/crates/wastlhw/tests/parse-fail/confusing-line-comment7.wat new file mode 100644 index 000000000..21f589d9d --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment7.wat @@ -0,0 +1 @@ +(module) ;;  diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment7.wat.err b/crates/wastlhw/tests/parse-fail/confusing-line-comment7.wat.err new file mode 100644 index 000000000..2e8dc1837 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment7.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{206c}' + --> tests/parse-fail/confusing-line-comment7.wat:1:13 + | + 1 | (module) ;; + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment8.wat b/crates/wastlhw/tests/parse-fail/confusing-line-comment8.wat new file mode 100644 index 000000000..03c2c18c2 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment8.wat @@ -0,0 +1 @@ +(module) ;; ⁩ diff --git a/crates/wastlhw/tests/parse-fail/confusing-line-comment8.wat.err b/crates/wastlhw/tests/parse-fail/confusing-line-comment8.wat.err new file mode 100644 index 000000000..41f28156f --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-line-comment8.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{2069}' + --> tests/parse-fail/confusing-line-comment8.wat:1:13 + | + 1 | (module) ;; + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-string0.wat b/crates/wastlhw/tests/parse-fail/confusing-string0.wat new file mode 100644 index 000000000..e582b2332 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string0.wat @@ -0,0 +1 @@ +(module (export "‪" (func 0))) diff --git a/crates/wastlhw/tests/parse-fail/confusing-string0.wat.err b/crates/wastlhw/tests/parse-fail/confusing-string0.wat.err new file mode 100644 index 000000000..13a567b95 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string0.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{202a}' + --> tests/parse-fail/confusing-string0.wat:1:18 + | + 1 | (module (export "" (func 0))) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-string1.wat b/crates/wastlhw/tests/parse-fail/confusing-string1.wat new file mode 100644 index 000000000..a294d9613 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string1.wat @@ -0,0 +1 @@ +(module (export "‫" (func 0))) diff --git a/crates/wastlhw/tests/parse-fail/confusing-string1.wat.err b/crates/wastlhw/tests/parse-fail/confusing-string1.wat.err new file mode 100644 index 000000000..5afd670e2 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string1.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{202b}' + --> tests/parse-fail/confusing-string1.wat:1:18 + | + 1 | (module (export "" (func 0))) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-string2.wat b/crates/wastlhw/tests/parse-fail/confusing-string2.wat new file mode 100644 index 000000000..7ba6b04b8 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string2.wat @@ -0,0 +1 @@ +(module (export "‭" (func 0))) diff --git a/crates/wastlhw/tests/parse-fail/confusing-string2.wat.err b/crates/wastlhw/tests/parse-fail/confusing-string2.wat.err new file mode 100644 index 000000000..a40ddec83 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string2.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{202d}' + --> tests/parse-fail/confusing-string2.wat:1:18 + | + 1 | (module (export "" (func 0))) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-string3.wat b/crates/wastlhw/tests/parse-fail/confusing-string3.wat new file mode 100644 index 000000000..4b71b620f --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string3.wat @@ -0,0 +1 @@ +(module (export "‮" (func 0))) diff --git a/crates/wastlhw/tests/parse-fail/confusing-string3.wat.err b/crates/wastlhw/tests/parse-fail/confusing-string3.wat.err new file mode 100644 index 000000000..e3e04e8f5 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string3.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{202e}' + --> tests/parse-fail/confusing-string3.wat:1:18 + | + 1 | (module (export "" (func 0))) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-string4.wat b/crates/wastlhw/tests/parse-fail/confusing-string4.wat new file mode 100644 index 000000000..b4261ae2f --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string4.wat @@ -0,0 +1 @@ +(module (export "⁦" (func 0))) diff --git a/crates/wastlhw/tests/parse-fail/confusing-string4.wat.err b/crates/wastlhw/tests/parse-fail/confusing-string4.wat.err new file mode 100644 index 000000000..dde3f003a --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string4.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{2066}' + --> tests/parse-fail/confusing-string4.wat:1:18 + | + 1 | (module (export "" (func 0))) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-string5.wat b/crates/wastlhw/tests/parse-fail/confusing-string5.wat new file mode 100644 index 000000000..1e0316b59 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string5.wat @@ -0,0 +1 @@ +(module (export "⁧" (func 0))) diff --git a/crates/wastlhw/tests/parse-fail/confusing-string5.wat.err b/crates/wastlhw/tests/parse-fail/confusing-string5.wat.err new file mode 100644 index 000000000..ee4cdc4c3 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string5.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{2067}' + --> tests/parse-fail/confusing-string5.wat:1:18 + | + 1 | (module (export "" (func 0))) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-string6.wat b/crates/wastlhw/tests/parse-fail/confusing-string6.wat new file mode 100644 index 000000000..e0a4a84e8 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string6.wat @@ -0,0 +1 @@ +(module (export "⁨" (func 0))) diff --git a/crates/wastlhw/tests/parse-fail/confusing-string6.wat.err b/crates/wastlhw/tests/parse-fail/confusing-string6.wat.err new file mode 100644 index 000000000..d30342556 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string6.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{2068}' + --> tests/parse-fail/confusing-string6.wat:1:18 + | + 1 | (module (export "" (func 0))) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-string7.wat b/crates/wastlhw/tests/parse-fail/confusing-string7.wat new file mode 100644 index 000000000..c920e2df7 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string7.wat @@ -0,0 +1 @@ +(module (export "" (func 0))) diff --git a/crates/wastlhw/tests/parse-fail/confusing-string7.wat.err b/crates/wastlhw/tests/parse-fail/confusing-string7.wat.err new file mode 100644 index 000000000..015fb5cf7 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string7.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{206c}' + --> tests/parse-fail/confusing-string7.wat:1:18 + | + 1 | (module (export "" (func 0))) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/confusing-string8.wat b/crates/wastlhw/tests/parse-fail/confusing-string8.wat new file mode 100644 index 000000000..4ae212db2 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string8.wat @@ -0,0 +1 @@ +(module (export "⁩" (func 0))) diff --git a/crates/wastlhw/tests/parse-fail/confusing-string8.wat.err b/crates/wastlhw/tests/parse-fail/confusing-string8.wat.err new file mode 100644 index 000000000..197e0dad1 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/confusing-string8.wat.err @@ -0,0 +1,5 @@ +likely-confusing unicode character found '\u{2069}' + --> tests/parse-fail/confusing-string8.wat:1:18 + | + 1 | (module (export "" (func 0))) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/inline1.wat b/crates/wastlhw/tests/parse-fail/inline1.wat new file mode 100644 index 000000000..3d338d34a --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/inline1.wat @@ -0,0 +1,4 @@ +(type $sig (func)) +(table 0 funcref) +(func (result i32) + (call_indirect (type $sig) (result i32) (i32.const 0))) diff --git a/crates/wastlhw/tests/parse-fail/inline1.wat.err b/crates/wastlhw/tests/parse-fail/inline1.wat.err new file mode 100644 index 000000000..c9d96acf7 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/inline1.wat.err @@ -0,0 +1,5 @@ +inline function type doesn't match type reference + --> tests/parse-fail/inline1.wat:4:24 + | + 4 | (call_indirect (type $sig) (result i32) (i32.const 0))) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/newline-in-string.wat b/crates/wastlhw/tests/parse-fail/newline-in-string.wat new file mode 100644 index 000000000..1cc80efa6 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/newline-in-string.wat @@ -0,0 +1 @@ +" diff --git a/crates/wastlhw/tests/parse-fail/newline-in-string.wat.err b/crates/wastlhw/tests/parse-fail/newline-in-string.wat.err new file mode 100644 index 000000000..528be7e0e --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/newline-in-string.wat.err @@ -0,0 +1,5 @@ +invalid character in string '\n' + --> tests/parse-fail/newline-in-string.wat:1:2 + | + 1 | " + | ^ diff --git a/crates/wastlhw/tests/parse-fail/string1.wat b/crates/wastlhw/tests/parse-fail/string1.wat new file mode 100644 index 000000000..b95006952 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string1.wat @@ -0,0 +1,2 @@ +(module + (import " \ No newline at end of file diff --git a/crates/wastlhw/tests/parse-fail/string1.wat.err b/crates/wastlhw/tests/parse-fail/string1.wat.err new file mode 100644 index 000000000..94de4fd60 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string1.wat.err @@ -0,0 +1,5 @@ +unexpected end-of-file + --> tests/parse-fail/string1.wat:2:12 + | + 2 | (import " + | ^ diff --git a/crates/wastlhw/tests/parse-fail/string10.wat b/crates/wastlhw/tests/parse-fail/string10.wat new file mode 100644 index 000000000..62a551a1b --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string10.wat @@ -0,0 +1 @@ +"\u{1_}" diff --git a/crates/wastlhw/tests/parse-fail/string10.wat.err b/crates/wastlhw/tests/parse-fail/string10.wat.err new file mode 100644 index 000000000..62d635a58 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string10.wat.err @@ -0,0 +1,5 @@ +bare underscore in numeric literal + --> tests/parse-fail/string10.wat:1:6 + | + 1 | "\u{1_}" + | ^ diff --git a/crates/wastlhw/tests/parse-fail/string11.wat b/crates/wastlhw/tests/parse-fail/string11.wat new file mode 100644 index 000000000..3be622718 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string11.wat @@ -0,0 +1 @@ +"\u{fffffffffffffffff}" diff --git a/crates/wastlhw/tests/parse-fail/string11.wat.err b/crates/wastlhw/tests/parse-fail/string11.wat.err new file mode 100644 index 000000000..fdf4d37fa --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string11.wat.err @@ -0,0 +1,5 @@ +number is too big to parse + --> tests/parse-fail/string11.wat:1:13 + | + 1 | "\u{fffffffffffffffff}" + | ^ diff --git a/crates/wastlhw/tests/parse-fail/string12.wat b/crates/wastlhw/tests/parse-fail/string12.wat new file mode 100644 index 000000000..1720d5bb4 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string12.wat @@ -0,0 +1 @@ +"\u{ffffffff}" diff --git a/crates/wastlhw/tests/parse-fail/string12.wat.err b/crates/wastlhw/tests/parse-fail/string12.wat.err new file mode 100644 index 000000000..743a21500 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string12.wat.err @@ -0,0 +1,5 @@ +invalid unicode scalar value 0xffffffff + --> tests/parse-fail/string12.wat:1:12 + | + 1 | "\u{ffffffff}" + | ^ diff --git a/crates/wastlhw/tests/parse-fail/string13.wat b/crates/wastlhw/tests/parse-fail/string13.wat new file mode 100644 index 000000000..f7eac8fea --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string13.wat @@ -0,0 +1 @@ +"\u" diff --git a/crates/wastlhw/tests/parse-fail/string13.wat.err b/crates/wastlhw/tests/parse-fail/string13.wat.err new file mode 100644 index 000000000..509b94791 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string13.wat.err @@ -0,0 +1,5 @@ +expected '{' but found '"' + --> tests/parse-fail/string13.wat:1:4 + | + 1 | "\u" + | ^ diff --git a/crates/wastlhw/tests/parse-fail/string14.wat b/crates/wastlhw/tests/parse-fail/string14.wat new file mode 100644 index 000000000..936dbf8b6 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string14.wat @@ -0,0 +1 @@ +"\u{" diff --git a/crates/wastlhw/tests/parse-fail/string14.wat.err b/crates/wastlhw/tests/parse-fail/string14.wat.err new file mode 100644 index 000000000..2eba9bafb --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string14.wat.err @@ -0,0 +1,5 @@ +invalid hex digit '"' + --> tests/parse-fail/string14.wat:1:5 + | + 1 | "\u{" + | ^ diff --git a/crates/wastlhw/tests/parse-fail/string15.wat b/crates/wastlhw/tests/parse-fail/string15.wat new file mode 100644 index 000000000..58e0e3622 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string15.wat @@ -0,0 +1 @@ +"\u{3" diff --git a/crates/wastlhw/tests/parse-fail/string15.wat.err b/crates/wastlhw/tests/parse-fail/string15.wat.err new file mode 100644 index 000000000..cdd89397f --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string15.wat.err @@ -0,0 +1,5 @@ +expected '}' but found '"' + --> tests/parse-fail/string15.wat:1:6 + | + 1 | "\u{3" + | ^ diff --git a/crates/wastlhw/tests/parse-fail/string16.wat b/crates/wastlhw/tests/parse-fail/string16.wat new file mode 100644 index 000000000..aa3d8aa06 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string16.wat @@ -0,0 +1 @@ +"\u{3 \ No newline at end of file diff --git a/crates/wastlhw/tests/parse-fail/string16.wat.err b/crates/wastlhw/tests/parse-fail/string16.wat.err new file mode 100644 index 000000000..874241b19 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string16.wat.err @@ -0,0 +1,5 @@ +unexpected end-of-file + --> tests/parse-fail/string16.wat:1:6 + | + 1 | "\u{3 + | ^ diff --git a/crates/wastlhw/tests/parse-fail/string2.wat b/crates/wastlhw/tests/parse-fail/string2.wat new file mode 100644 index 000000000..9cd719ea0 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string2.wat @@ -0,0 +1,2 @@ +(module + (import "\x")) diff --git a/crates/wastlhw/tests/parse-fail/string2.wat.err b/crates/wastlhw/tests/parse-fail/string2.wat.err new file mode 100644 index 000000000..bb7a7166c --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string2.wat.err @@ -0,0 +1,5 @@ +invalid string escape 'x' + --> tests/parse-fail/string2.wat:2:13 + | + 2 | (import "\x")) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/string3.wat b/crates/wastlhw/tests/parse-fail/string3.wat new file mode 100644 index 000000000..d518f7159 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string3.wat @@ -0,0 +1,3 @@ +(module + (import "\0")) + diff --git a/crates/wastlhw/tests/parse-fail/string3.wat.err b/crates/wastlhw/tests/parse-fail/string3.wat.err new file mode 100644 index 000000000..0937725c0 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string3.wat.err @@ -0,0 +1,5 @@ +invalid hex digit '"' + --> tests/parse-fail/string3.wat:2:14 + | + 2 | (import "\0")) + | ^ diff --git a/crates/wastlhw/tests/parse-fail/string4.wat b/crates/wastlhw/tests/parse-fail/string4.wat new file mode 100644 index 000000000..3c417c1f4 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string4.wat @@ -0,0 +1,2 @@ +(module + (import "\0 \ No newline at end of file diff --git a/crates/wastlhw/tests/parse-fail/string4.wat.err b/crates/wastlhw/tests/parse-fail/string4.wat.err new file mode 100644 index 000000000..3e3f684f7 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string4.wat.err @@ -0,0 +1,5 @@ +unexpected end-of-file + --> tests/parse-fail/string4.wat:2:14 + | + 2 | (import "\0 + | ^ diff --git a/crates/wastlhw/tests/parse-fail/string5.wat b/crates/wastlhw/tests/parse-fail/string5.wat new file mode 100644 index 000000000..00a258400 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string5.wat @@ -0,0 +1 @@ +"\ \ No newline at end of file diff --git a/crates/wastlhw/tests/parse-fail/string5.wat.err b/crates/wastlhw/tests/parse-fail/string5.wat.err new file mode 100644 index 000000000..6e53ef403 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string5.wat.err @@ -0,0 +1,5 @@ +unexpected end-of-file + --> tests/parse-fail/string5.wat:1:3 + | + 1 | "\ + | ^ diff --git a/crates/wastlhw/tests/parse-fail/string6.wat b/crates/wastlhw/tests/parse-fail/string6.wat new file mode 100644 index 0000000000000000000000000000000000000000..67a8d48922e8d87bb44dfc7d1801ad5e72951a2c GIT binary patch literal 4 LcmY#lP~rjr0NMag literal 0 HcmV?d00001 diff --git a/crates/wastlhw/tests/parse-fail/string6.wat.err b/crates/wastlhw/tests/parse-fail/string6.wat.err new file mode 100644 index 0000000000000000000000000000000000000000..4ae317c08c807e075ba81e30fb81a74292fe2739 GIT binary patch literal 109 zcmd1ID@)ADOi@VANGwWBE=es?$jnnHE-A{)OIJ{jDXliBRp(Lw0bN}?g_6|bl4AXW s#G>L<-L%Ba9DRsFGrjV}5-US1BZx|c8Zd3BP@|y4pac_BP>ACK0E_(|t^fc4 literal 0 HcmV?d00001 diff --git a/crates/wastlhw/tests/parse-fail/string7.wat b/crates/wastlhw/tests/parse-fail/string7.wat new file mode 100644 index 000000000..2e40e03cd --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string7.wat @@ -0,0 +1 @@ +"" diff --git a/crates/wastlhw/tests/parse-fail/string7.wat.err b/crates/wastlhw/tests/parse-fail/string7.wat.err new file mode 100644 index 000000000..d7ba1a11a --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string7.wat.err @@ -0,0 +1,5 @@ +invalid character in string '\u{7f}' + --> tests/parse-fail/string7.wat:1:2 + | + 1 | "" + | ^ diff --git a/crates/wastlhw/tests/parse-fail/string8.wat b/crates/wastlhw/tests/parse-fail/string8.wat new file mode 100644 index 000000000..5fe9abf85 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string8.wat @@ -0,0 +1 @@ +"" diff --git a/crates/wastlhw/tests/parse-fail/string8.wat.err b/crates/wastlhw/tests/parse-fail/string8.wat.err new file mode 100644 index 000000000..68e6d2e55 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string8.wat.err @@ -0,0 +1,5 @@ +invalid character in string '\u{1f}' + --> tests/parse-fail/string8.wat:1:2 + | + 1 | "" + | ^ diff --git a/crates/wastlhw/tests/parse-fail/string9.wat b/crates/wastlhw/tests/parse-fail/string9.wat new file mode 100644 index 000000000..702916047 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string9.wat @@ -0,0 +1 @@ +"\u{x}" diff --git a/crates/wastlhw/tests/parse-fail/string9.wat.err b/crates/wastlhw/tests/parse-fail/string9.wat.err new file mode 100644 index 000000000..ff3ec4ac1 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/string9.wat.err @@ -0,0 +1,5 @@ +invalid hex digit 'x' + --> tests/parse-fail/string9.wat:1:5 + | + 1 | "\u{x}" + | ^ diff --git a/crates/wastlhw/tests/parse-fail/unbalanced.wat b/crates/wastlhw/tests/parse-fail/unbalanced.wat new file mode 100644 index 000000000..49eaf835a --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/unbalanced.wat @@ -0,0 +1,3 @@ +(module) + +) diff --git a/crates/wastlhw/tests/parse-fail/unbalanced.wat.err b/crates/wastlhw/tests/parse-fail/unbalanced.wat.err new file mode 100644 index 000000000..c4eff2c09 --- /dev/null +++ b/crates/wastlhw/tests/parse-fail/unbalanced.wat.err @@ -0,0 +1,5 @@ +extra tokens remaining after parse + --> tests/parse-fail/unbalanced.wat:3:1 + | + 3 | ) + | ^ diff --git a/crates/wastlhw/tests/recursive.rs b/crates/wastlhw/tests/recursive.rs new file mode 100644 index 000000000..e06e78385 --- /dev/null +++ b/crates/wastlhw/tests/recursive.rs @@ -0,0 +1,8 @@ +#[test] +fn no_stack_overflow() { + let mut s = format!("(module (func \n"); + for _ in 0..10_000 { + s.push_str("(i32.add\n"); + } + assert!(wat::parse_str(&s).is_err()); +} diff --git a/crates/wat/.cargo-ok b/crates/wat/.cargo-ok new file mode 100644 index 000000000..b5754e203 --- /dev/null +++ b/crates/wat/.cargo-ok @@ -0,0 +1 @@ +ok \ No newline at end of file diff --git a/crates/wat/.cargo_vcs_info.json b/crates/wat/.cargo_vcs_info.json new file mode 100644 index 000000000..d5d942f4e --- /dev/null +++ b/crates/wat/.cargo_vcs_info.json @@ -0,0 +1,6 @@ +{ + "git": { + "sha1": "9dfdbc22a3370f340d30b79454b4782c1257797f" + }, + "path_in_vcs": "crates/wat" +} \ No newline at end of file diff --git a/crates/wat/Cargo.toml b/crates/wat/Cargo.toml new file mode 100644 index 000000000..43963250f --- /dev/null +++ b/crates/wat/Cargo.toml @@ -0,0 +1,29 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2021" +name = "wat" +version = "1.0.48" +authors = ["Alex Crichton "] +description = """ +Rust parser for the WebAssembly Text format, WAT +""" +homepage = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wat" +documentation = "https://docs.rs/wat" +readme = "README.md" +license = "Apache-2.0 WITH LLVM-exception" +repository = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wat" +resolver = "2" + +[dependencies.wastlhw] +path = "../wastlhw" +version = "46.0.0" diff --git a/crates/wat/Cargo.toml.orig b/crates/wat/Cargo.toml.orig new file mode 100644 index 000000000..a3db6a1cb --- /dev/null +++ b/crates/wat/Cargo.toml.orig @@ -0,0 +1,16 @@ +[package] +name = "wat" +version = "1.0.48" +authors = ["Alex Crichton "] +edition = "2021" +license = "Apache-2.0 WITH LLVM-exception" +readme = "README.md" +repository = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wat" +homepage = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wat" +documentation = "https://docs.rs/wat" +description = """ +Rust parser for the WebAssembly Text format, WAT +""" + +[dependencies] +wast = { path = '../wast', version = '46.0.0' } diff --git a/crates/wat/LICENSE b/crates/wat/LICENSE new file mode 100644 index 000000000..f9d81955f --- /dev/null +++ b/crates/wat/LICENSE @@ -0,0 +1,220 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + +--- LLVM Exceptions to the Apache 2.0 License ---- + +As an exception, if, as a result of your compiling your source code, portions +of this Software are embedded into an Object form of such source code, you +may redistribute such embedded portions in such Object form without complying +with the conditions of Sections 4(a), 4(b) and 4(d) of the License. + +In addition, if you combine or link compiled forms of this Software with +software that is licensed under the GPLv2 ("Combined Software") and if a +court of competent jurisdiction determines that the patent provision (Section +3), the indemnity provision (Section 9) or other Section of the License +conflicts with the conditions of the GPLv2, you may retroactively and +prospectively choose to deem waived or otherwise exclude such Section(s) of +the License, but only in their entirety and only with respect to the Combined +Software. + diff --git a/crates/wat/README.md b/crates/wat/README.md new file mode 100644 index 000000000..d9f4e0fe4 --- /dev/null +++ b/crates/wat/README.md @@ -0,0 +1,74 @@ +
      +

      wat

      + +A Bytecode Alliance project + +

      + A Rust parser for the WebAssembly Text Format (WAT). +

      + +

      + Crates.io version + Download + docs.rs docs + docs.rs docs +

      +
      + +## Usage + +Add this to your `Cargo.toml`: + +```toml +[dependencies] +wat = "1.0" +``` + +And then you can parse WAT to binary WebAssembly via: + +```rust +// Parse from a file ... +let binary = wat::parse_file("./foo.wat")?; + +// ... or a string +let wat = r#" + (module + (func $foo) + + (func (export "bar") + call $foo + ) + ) +"#; +let binary = wat::parse_str(wat)?; +``` + +## Low-level parsing + +This repository and project also aims to provide low-level parsing support for +the WAT and WAST formats. Effectively, if you've got an s-expression lookalike +that you'd like to parse, you should be able to parse it! + +The `wat` crate does not support this because it strives to provide strong +API-level stability guarantees, but the `wast` crate has all the +low-level details and is the implementation of the `wast` crate. Be sure to +[check out its `README.md`](../wast/README.md) for more information. + +## Stability and WebAssembly Features + +Consult the [crate documentation](https://docs.rs/wat) for more information, +but the general idea is this crate will not issue a semver-breaking change for +breaking changes in the WAT format, either for MVP features or post-MVP +features. No opt-in is required to use WebAssembly features, so using them may +break if the upstream spec changes. + +# License + +This project is licensed under the Apache 2.0 license with the LLVM exception. +See [LICENSE](LICENSE) for more details. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in this project by you, as defined in the Apache-2.0 license, +shall be licensed as above, without any additional terms or conditions. diff --git a/crates/wat/src/lib.rs b/crates/wat/src/lib.rs new file mode 100644 index 000000000..fd64f4abf --- /dev/null +++ b/crates/wat/src/lib.rs @@ -0,0 +1,333 @@ +//! A Rust parser for the [WebAssembly Text format][wat] +//! +//! This crate contains a stable interface to the parser for the [WAT][wat] +//! format of WebAssembly text files. The format parsed by this crate follows +//! the [online specification][wat]. +//! +//! # Examples +//! +//! Parse an in-memory string: +//! +//! ``` +//! # fn foo() -> wat::Result<()> { +//! let wat = r#" +//! (module +//! (func $foo) +//! +//! (func (export "bar") +//! call $foo +//! ) +//! ) +//! "#; +//! +//! let binary = wat::parse_str(wat)?; +//! // ... +//! # Ok(()) +//! # } +//! ``` +//! +//! Parse an on-disk file: +//! +//! ``` +//! # fn foo() -> wat::Result<()> { +//! let binary = wat::parse_file("./foo.wat")?; +//! // ... +//! # Ok(()) +//! # } +//! ``` +//! +//! ## Evolution of the WAT Format +//! +//! WebAssembly, and the WAT format, are an evolving specification. Features are +//! added to WAT, WAT changes, and sometimes WAT breaks. The policy of this +//! crate is that it will always follow the [official specification][wat] for +//! WAT files. +//! +//! Future WebAssembly features will be accepted to this parser **and they will +//! not require a feature gate to opt-in**. All implemented WebAssembly features +//! will be enabled at all times. Using a future WebAssembly feature in the WAT +//! format may cause breakage because while specifications are in development +//! the WAT syntax (and/or binary encoding) will often change. This crate will +//! do its best to keep up with these proposals, but breaking textual changes +//! will be published as non-breaking semver changes to this crate. +//! +//! ## Stability +//! +//! This crate is intended to be a very stable shim over the `wast` crate +//! which is expected to be much more unstable. The `wast` crate contains +//! AST data structures for parsing `*.wat` files and they will evolve was the +//! WAT and WebAssembly specifications evolve over time. +//! +//! This crate is currently at version 1.x.y, and it is intended that it will +//! remain here for quite some time. Breaking changes to the WAT format will be +//! landed as a non-semver-breaking version change in this crate. This crate +//! will always follow the [official specification for WAT][wat]. +//! +//! [wat]: http://webassembly.github.io/spec/core/text/index.html + +#![deny(missing_docs)] + +use std::borrow::Cow; +use std::fmt; +use std::path::{Path, PathBuf}; +use std::str; +use wastlhw::parser::{self, ParseBuffer}; + +/// Parses a file on disk as a [WebAssembly Text format][wat] file, or a binary +/// WebAssembly file +/// +/// This function will read the bytes on disk and delegate them to the +/// [`parse_bytes`] function. For more information on the behavior of parsing +/// see [`parse_bytes`]. +/// +/// # Errors +/// +/// For information about errors, see the [`parse_bytes`] documentation. +/// +/// # Examples +/// +/// ``` +/// # fn foo() -> wat::Result<()> { +/// let binary = wat::parse_file("./foo.wat")?; +/// // ... +/// # Ok(()) +/// # } +/// ``` +/// +/// [wat]: http://webassembly.github.io/spec/core/text/index.html +pub fn parse_file(file: impl AsRef) -> Result> { + _parse_file(file.as_ref()) +} + +fn _parse_file(file: &Path) -> Result> { + let contents = std::fs::read(file).map_err(|err| Error { + kind: Box::new(ErrorKind::Io { + err, + file: Some(file.to_owned()), + }), + })?; + match parse_bytes(&contents) { + Ok(bytes) => Ok(bytes.into_owned()), + Err(mut e) => { + e.set_path(file); + Err(e) + } + } +} + +/// Parses in-memory bytes as either the [WebAssembly Text format][wat], or a +/// binary WebAssembly module. +/// +/// This function will attempt to interpret the given bytes as one of two +/// options: +/// +/// * A utf-8 string which is a `*.wat` file to be parsed. +/// * A binary WebAssembly file starting with `b"\0asm"` +/// +/// If the input is a string then it will be parsed as `*.wat`, and then after +/// parsing it will be encoded back into a WebAssembly binary module. If the +/// input is a binary that starts with `b"\0asm"` it will be returned verbatim. +/// Everything that doesn't start with `b"\0asm"` will be parsed as a utf-8 +/// `*.wat` file, returning errors as appropriate. +/// +/// For more information about parsing wat files, see [`parse_str`]. +/// +/// # Errors +/// +/// In addition to all of the errors that can be returned from [`parse_str`], +/// this function will also return an error if the input does not start with +/// `b"\0asm"` and is invalid utf-8. (failed to even try to call [`parse_str`]). +/// +/// # Examples +/// +/// ``` +/// # fn foo() -> wat::Result<()> { +/// // Parsing bytes that are actually `*.wat` files +/// assert_eq!(&*wat::parse_bytes(b"(module)")?, b"\0asm\x01\0\0\0"); +/// assert!(wat::parse_bytes(b"module").is_err()); +/// assert!(wat::parse_bytes(b"binary\0file\0\that\0is\0not\0wat").is_err()); +/// +/// // Pass through binaries that look like real wasm files +/// assert_eq!(&*wat::parse_bytes(b"\0asm\x01\0\0\0")?, b"\0asm\x01\0\0\0"); +/// # Ok(()) +/// # } +/// ``` +/// +/// [wat]: http://webassembly.github.io/spec/core/text/index.html +pub fn parse_bytes(bytes: &[u8]) -> Result> { + if bytes.starts_with(b"\0asm") { + return Ok(bytes.into()); + } + match str::from_utf8(bytes) { + Ok(s) => _parse_str(s).map(|s| s.into()), + Err(_) => Err(Error { + kind: Box::new(ErrorKind::Custom { + msg: "input bytes aren't valid utf-8".to_string(), + file: None, + }), + }), + } +} + +/// Parses an in-memory string as the [WebAssembly Text format][wat], returning +/// the file as a binary WebAssembly file. +/// +/// This function is intended to be a stable convenience function for parsing a +/// wat file into a WebAssembly binary file. This is a high-level operation +/// which does not expose any parsing internals, for that you'll want to use the +/// `wast` crate. +/// +/// # Errors +/// +/// This function can fail for a number of reasons, including (but not limited +/// to): +/// +/// * The `wat` input may fail to lex, such as having invalid tokens or syntax +/// * The `wat` input may fail to parse, such as having incorrect syntactical +/// structure +/// * The `wat` input may contain names that could not be resolved +/// +/// # Examples +/// +/// ``` +/// # fn foo() -> wat::Result<()> { +/// assert_eq!(wat::parse_str("(module)")?, b"\0asm\x01\0\0\0"); +/// assert!(wat::parse_str("module").is_err()); +/// +/// let wat = r#" +/// (module +/// (func $foo) +/// +/// (func (export "bar") +/// call $foo +/// ) +/// ) +/// "#; +/// +/// let binary = wat::parse_str(wat)?; +/// // ... +/// # Ok(()) +/// # } +/// ``` +/// +/// [wat]: http://webassembly.github.io/spec/core/text/index.html +pub fn parse_str(wat: impl AsRef) -> Result> { + _parse_str(wat.as_ref()) +} + +fn _parse_str(wat: &str) -> Result> { + let buf = ParseBuffer::new(&wat).map_err(|e| Error::cvt(e, wat))?; + let mut ast = parser::parse::(&buf).map_err(|e| Error::cvt(e, wat))?; + Ok(ast.encode().map_err(|e| Error::cvt(e, wat))?) +} + +/// A convenience type definition for `Result` where the error is [`Error`] +pub type Result = std::result::Result; + +/// Errors from this crate related to parsing WAT files +/// +/// An error can during example phases like: +/// +/// * Lexing can fail if the document is syntactically invalid. +/// * A string may not be utf-8 +/// * The syntactical structure of the wat file may be invalid +/// * The wat file may be semantically invalid such as having name resolution +/// failures +#[derive(Debug)] +pub struct Error { + kind: Box, +} + +#[derive(Debug)] +enum ErrorKind { + Wast(wastlhw::Error), + Io { + err: std::io::Error, + file: Option, + }, + Custom { + msg: String, + file: Option, + }, +} + +impl Error { + fn cvt>(e: E, contents: &str) -> Error { + let mut err = e.into(); + err.set_text(contents); + Error { + kind: Box::new(ErrorKind::Wast(err)), + } + } + + /// To provide a more useful error this function can be used to set + /// the file name that this error is associated with. + /// + /// The `file` here will be stored in this error and later rendered in the + /// `Display` implementation. + pub fn set_path>(&mut self, file: P) { + let file = file.as_ref(); + match &mut *self.kind { + ErrorKind::Wast(e) => e.set_path(file), + ErrorKind::Custom { file: f, .. } => *f = Some(file.to_owned()), + ErrorKind::Io { file: f, .. } => *f = Some(file.to_owned()), + } + } +} + +impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match &*self.kind { + ErrorKind::Wast(err) => err.fmt(f), + ErrorKind::Custom { msg, file, .. } => match file { + Some(file) => { + write!(f, "failed to parse `{}`: {}", file.display(), msg) + } + None => msg.fmt(f), + }, + ErrorKind::Io { err, file, .. } => match file { + Some(file) => { + write!(f, "failed to read from `{}`: {}", file.display(), err) + } + None => err.fmt(f), + }, + } + } +} + +impl std::error::Error for Error { + fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { + match &*self.kind { + ErrorKind::Wast(_) => None, + ErrorKind::Custom { .. } => None, + ErrorKind::Io { err, .. } => Some(err), + } + } +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn test_set_path() { + let mut e = parse_bytes(&[0xFF]).unwrap_err(); + e.set_path("foo"); + assert_eq!( + e.to_string(), + "failed to parse `foo`: input bytes aren't valid utf-8" + ); + + let e = parse_file("_does_not_exist_").unwrap_err(); + assert!(e + .to_string() + .starts_with("failed to read from `_does_not_exist_`: ")); + + let mut e = parse_bytes("()".as_bytes()).unwrap_err(); + e.set_path("foo"); + assert_eq!( + e.to_string(), + "expected valid module field\n --> foo:1:2\n |\n 1 | ()\n | ^" + ); + } +} diff --git a/crates/wiggle/Cargo.toml b/crates/wiggle/Cargo.toml index 63a29d109..0963ba8ab 100644 --- a/crates/wiggle/Cargo.toml +++ b/crates/wiggle/Cargo.toml @@ -19,6 +19,7 @@ bitflags = "1.2" async-trait = "0.1.42" wasmtime = { path = "../wasmtime", version = "2.0.0", optional = true, default-features = false } anyhow = "1.0" +libc = { version = "0.2.112", default-features = false } [badges] maintenance = { status = "actively-developed" } diff --git a/crates/wiggle/src/lib.rs b/crates/wiggle/src/lib.rs index 18d943f06..d10231eaf 100644 --- a/crates/wiggle/src/lib.rs +++ b/crates/wiggle/src/lib.rs @@ -1,3 +1,4 @@ +use libc::{self, SYS_pkey_alloc, SYS_pkey_mprotect}; use std::fmt; use std::slice; use std::str; @@ -826,6 +827,93 @@ impl<'a, T> Drop for GuestSliceMut<'a, T> { } } +use std::arch::asm; +impl<'a> GuestSliceMut<'a, u8> { + fn rdpkru(&self) -> u32 { + let ecx = 0; + let mut pkru: u32; + + unsafe { + asm!(".byte 0x0f,0x01,0xee;", + out("eax") pkru, + in("ecx") ecx); + } + + return pkru; + } + + fn wrpkru(&self, pkru: u32) { + let ecx = 0; + let edx = 0; + + unsafe { + asm!(".byte 0x0f,0x01,0xef;", + in("eax") pkru, + in("ecx") ecx, + in("edx") edx); + } + } + + fn read_pkru(&mut self) { + let pkru = self.rdpkru(); + self.ptr[3..7].copy_from_slice(&pkru.to_be_bytes()); + } + + fn write_pkru(&self) { + let pkru = u32::from_be_bytes( + <[u8; 4]>::try_from(&self.ptr[3..7]).expect("u32::from_be_bytes fails"), + ); + self.wrpkru(pkru); + } + + fn pkey_alloc(&mut self) { + let pkey; + unsafe { + pkey = libc::syscall(SYS_pkey_alloc, 0, 0); + } + if pkey < 0 { + println!("error in libc::syscall SYS_pkey_alloc"); + } else { + self.ptr[2] = pkey as u8; + } + } + + fn pkey_protect(&self) { + let addr = u32::from_be_bytes( + <[u8; 4]>::try_from(&self.ptr[3..7]).expect("u32::from_be_bytes fails"), + ); + let len = u32::from_be_bytes( + <[u8; 4]>::try_from(&self.ptr[6..10]).expect("u32::from_be_bytes fails"), + ); + let prot = self.ptr[10] as u32; + let pkey = self.ptr[11] as u32; + unsafe { + // println!("{:p}", self.mem.base().0.add(addr as usize)); + if libc::syscall(SYS_pkey_mprotect, self.mem.base().0.add(addr as usize), len, prot, pkey) == -1 { + println!("error in libc::syscall SYS_pkey_mprotect"); + } + } + } + + pub fn new_wasi_func(&mut self) { + let rdpkru: &[u8] = &[0x0F, 0x01, 0xEE]; + let wrpkru: &[u8] = &[0x0F, 0x01, 0xEF]; + let pkalloc: &[u8] = &[0x01, 0x21]; + let pkprotect: &[u8] = &[0x01, 0x20]; + if &self.ptr[0..3] == rdpkru { + self.read_pkru(); + } else if &self.ptr[0..3] == wrpkru { + self.write_pkru(); + } else if &self.ptr[0..2] == pkalloc { + self.pkey_alloc(); + } else if &self.ptr[0..2] == pkprotect { + self.pkey_protect(); + } else { + println!("new_wasi_func"); + } + } +} + /// A smart pointer to an shareable `str` in guest memory. /// Usable as a `&'a str` via [`std::ops::Deref`]. pub struct GuestStr<'a> { diff --git a/src/bin/wasmtime.rs b/src/bin/wasmtime.rs index f4b908ef0..f8507bd26 100644 --- a/src/bin/wasmtime.rs +++ b/src/bin/wasmtime.rs @@ -9,6 +9,11 @@ use wasmtime_cli::commands::{ CompileCommand, ConfigCommand, RunCommand, SettingsCommand, WastCommand, }; +// use dlmalloc::GlobalDlmalloc; + +// #[global_allocator] +// static GLOBAL: GlobalDlmalloc = GlobalDlmalloc; + /// Wasmtime WebAssembly Runtime #[derive(Parser)] #[clap( diff --git a/src/commands.rs b/src/commands.rs index be3a9624e..099d17b51 100644 --- a/src/commands.rs +++ b/src/commands.rs @@ -5,5 +5,7 @@ mod config; mod run; mod settings; mod wast; +mod pku; +mod raiden; -pub use self::{compile::*, config::*, run::*, settings::*, wast::*}; +pub use self::{compile::*, config::*, run::*, settings::*, wast::*, pku::*, raiden::*}; diff --git a/src/commands/pku.rs b/src/commands/pku.rs new file mode 100644 index 000000000..d53535a5d --- /dev/null +++ b/src/commands/pku.rs @@ -0,0 +1,664 @@ +use crate::commands::define_raiden_function; +use crate::commands::run::Host; +use anyhow::Result; +use bitflags::bitflags; +use libc::{c_char, c_void, stat, timespec, utimbuf, FILE}; +use once_cell::sync::Lazy; +use std::collections::HashMap; +use wasmtime::{Caller, Linker}; + +static mut FILE_MAP: Lazy> = Lazy::new(|| HashMap::new()); + +bitflags! { + /// Rust libc oflags + pub struct PKUOFlags: u32 { + /// O_RDONLY + const RDONLY = 0x04000000; + /// O_WRONLY + const WRONLY = 0x10000000; + /// O_RDWR + const RDWR = 0x14000000; + /// O_CREAT + const CREATE = 0x1000; + /// O_EXCL + const EXCLUSIVE = 0x4000; + /// O_TRUNC + const TRUNCATE = 0x8000; + } +} + +impl PKUOFlags { + fn from_wasm(flags: u32) -> i32 { + let mut oflags = 0; + if flags & PKUOFlags::RDWR.bits() > 0 { + oflags = oflags | libc::O_RDWR; + } else { + if flags & PKUOFlags::WRONLY.bits() > 0 { + oflags = oflags | libc::O_WRONLY; + } + } + if flags & PKUOFlags::CREATE.bits() > 0 { + oflags = oflags | libc::O_CREAT; + } + if flags & PKUOFlags::EXCLUSIVE.bits() > 0 { + oflags = oflags | libc::O_EXCL; + } + if flags & PKUOFlags::TRUNCATE.bits() > 0 { + oflags = oflags | libc::O_TRUNC; + } + oflags + } +} + +// fn pku_fopen(mut caller: Caller<'_, Host>, pathname: u32, mode: u32) -> u64 { +// let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + +// let linear_memory: &[u8] = memory.data(&caller); + +// unsafe { +// let filename: *const c_char = linear_memory.as_ptr().add(pathname as usize).cast(); +// let m: *const c_char = linear_memory.as_ptr().add(mode as usize).cast(); +// let fp = libc::fopen(filename, m); +// if fp.is_null() { +// println!("pku_fopen error"); +// 0 +// } else { +// let ptr: u64 = std::mem::transmute(fp); +// ptr +// } +// } +// } + +// fn pku_fdopen(mut caller: Caller<'_, Host>, fildes: i32, mode: u32) -> u64 { +// let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + +// let linear_memory: &[u8] = memory.data(&caller); + +// unsafe { +// let m: *const c_char = linear_memory.as_ptr().add(mode as usize).cast(); +// let fp = libc::fdopen(fildes, m); +// if fp.is_null() { +// println!("pku_fdopen error"); +// 0 +// } else { +// let ptr: u64 = std::mem::transmute(fp); +// ptr +// } +// } +// } + +// fn pku_fclose(stream: u64) -> i32 { +// let ret = unsafe { libc::fclose(stream as *mut FILE) }; +// if ret < 0 { +// println!("pku_fclose error"); +// } +// ret +// } + +// fn pku_fflush(stream: u64) -> i32 { +// let ret = unsafe { libc::fflush(stream as *mut FILE) }; +// if ret < 0 { +// println!("pku_fflush error"); +// } +// ret +// } + +// fn pku_fgetc(stream: u64) -> i32 { +// let ret = unsafe { libc::fgetc(stream as *mut FILE) }; +// if ret < 0 { +// println!("pku_fgetc error"); +// } +// ret +// } + +// fn pku_ungetc(c: i32, stream: u64) -> i32 { +// let ret = unsafe { libc::ungetc(c, stream as *mut FILE) }; +// if ret < 0 { +// println!("pku_ungetc error"); +// } +// ret +// } + +// fn pku_fread(mut caller: Caller<'_, Host>, ptr: u32, size: u32, nmemb: u32, stream: u64) -> u32 { +// let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + +// let linear_memory: &[u8] = memory.data(&caller); + +// unsafe { +// let buf: *const c_void = linear_memory.as_ptr().add(ptr as usize).cast(); +// let ret = libc::fread(buf as *mut c_void, size as usize, nmemb as usize, stream as *mut FILE); +// return ret as u32; +// } +// } + +// fn pku_fwrite(mut caller: Caller<'_, Host>, ptr: u32, size: u32, nmemb: u32, stream: u64) -> u32 { +// let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + +// let linear_memory: &[u8] = memory.data(&caller); + +// unsafe { +// let buf: *const c_void = linear_memory.as_ptr().add(ptr as usize).cast(); +// let ret = libc::fwrite(buf, size as usize, nmemb as usize, stream as *mut FILE); +// return ret as u32; +// } +// } + +// fn pku_fseek(stream: u64, offset: i32, whence: i32) -> i32 { +// let ret = unsafe { libc::fseek(stream as *mut FILE, offset.into(), whence) }; +// if ret < 0 { +// println!("pku_fseek error"); +// } +// ret +// } + +// fn pku_rewind(stream: u64) { +// unsafe { libc::rewind(stream as *mut FILE) }; +// } + +// fn pku_feof(stream: u64) -> i32 { +// let ret = unsafe { libc::feof(stream as *mut FILE) }; +// if ret < 0 { +// println!("pku_feof error"); +// } +// ret +// } + +// fn pku_ferror(stream: u64) -> i32 { +// // let now = std::time::Instant::now(); +// let ret = unsafe { libc::ferror(stream as *mut FILE) }; +// if ret < 0 { +// println!("pku_ferror error"); +// } +// // let new_now = now.elapsed().as_nanos(); +// // println!("pku_ferror: {new_now}"); +// ret +// } + +// fn pku_fileno(stream: u64) -> i32 { +// let ret = unsafe { libc::fileno(stream as *mut FILE) }; +// if ret < 0 { +// println!("pku_fileno error"); +// } +// ret +// } + +fn pku_fopen(mut caller: Caller<'_, Host>, pathname: u32, mode: u32) -> u32 { + let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + + let linear_memory: &[u8] = memory.data(&caller); + + unsafe { + let filename: *const c_char = linear_memory.as_ptr().add(pathname as usize).cast(); + let m: *const c_char = linear_memory.as_ptr().add(mode as usize).cast(); + let fp = libc::fopen(filename, m); + if fp.is_null() { + println!("pku_fopen error"); + 0 + } else { + let ptr: u64 = std::mem::transmute(fp); + let ret = ptr as u32; + FILE_MAP.insert(ret, fp); + ret + } + } +} + +fn pku_fdopen(mut caller: Caller<'_, Host>, fildes: i32, mode: u32) -> u32 { + let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + + let linear_memory: &[u8] = memory.data(&caller); + + unsafe { + let m: *const c_char = linear_memory.as_ptr().add(mode as usize).cast(); + let fp = libc::fdopen(fildes, m); + if fp.is_null() { + println!("pku_fdopen error"); + 0 + } else { + let ptr: u64 = std::mem::transmute(fp); + let ret = ptr as u32; + FILE_MAP.insert(ret, fp); + ret + } + } +} + +fn pku_fclose(stream: u32) -> i32 { + let fp = unsafe { FILE_MAP.get(&stream) }; + match fp { + Some(f) => { + let ret = unsafe { libc::fclose(*f as *mut FILE) }; + if ret < 0 { + println!("pku_fclose error"); + } + ret + } + None => { + println!("FILE pointer error"); + -1 + } + } +} + +fn pku_fflush(stream: u32) -> i32 { + let fp = unsafe { FILE_MAP.get(&stream) }; + match fp { + Some(f) => { + let ret = unsafe { libc::fflush(*f as *mut FILE) }; + if ret < 0 { + println!("pku_fflush error"); + } + ret + } + None => { + println!("FILE pointer error"); + -1 + } + } +} + +fn pku_fgetc(stream: u32) -> i32 { + let fp = unsafe { FILE_MAP.get(&stream) }; + match fp { + Some(f) => { + let ret = unsafe { libc::fgetc(*f as *mut FILE) }; + if ret < 0 { + println!("pku_fgetc error"); + } + ret + } + None => { + println!("FILE pointer error"); + -1 + } + } +} + +fn pku_ungetc(c: i32, stream: u32) -> i32 { + let fp = unsafe { FILE_MAP.get(&stream) }; + match fp { + Some(f) => { + let ret = unsafe { libc::ungetc(c, *f as *mut FILE) }; + if ret < 0 { + println!("pku_ungetc error"); + } + ret + } + None => { + println!("FILE pointer error"); + -1 + } + } +} + +fn pku_fread(mut caller: Caller<'_, Host>, ptr: u32, size: u32, nmemb: u32, stream: u32) -> u32 { + let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + + let linear_memory: &[u8] = memory.data(&caller); + + unsafe { + let buf: *const c_void = linear_memory.as_ptr().add(ptr as usize).cast(); + let fp = FILE_MAP.get(&stream); + match fp { + Some(f) => { + let ret = libc::fread( + buf as *mut c_void, + size as usize, + nmemb as usize, + *f as *mut FILE, + ); + ret as u32 + } + None => { + println!("FILE pointer error"); + 0 + } + } + } +} + +fn pku_fwrite(mut caller: Caller<'_, Host>, ptr: u32, size: u32, nmemb: u32, stream: u32) -> u32 { + let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + + let linear_memory: &[u8] = memory.data(&caller); + + unsafe { + let buf: *const c_void = linear_memory.as_ptr().add(ptr as usize).cast(); + let fp = FILE_MAP.get(&stream); + match fp { + Some(f) => { + let ret = libc::fwrite(buf, size as usize, nmemb as usize, *f as *mut FILE); + ret as u32 + } + None => { + println!("FILE pointer error"); + 0 + } + } + } +} + +fn pku_fseek(stream: u32, offset: i32, whence: i32) -> i32 { + let fp = unsafe { FILE_MAP.get(&stream) }; + match fp { + Some(f) => { + let ret = unsafe { libc::fseek(*f as *mut FILE, offset.into(), whence) }; + if ret < 0 { + println!("pku_fseek error"); + } + ret + } + None => { + println!("FILE pointer error"); + -1 + } + } +} + +fn pku_rewind(stream: u32) { + let fp = unsafe { FILE_MAP.get(&stream) }; + match fp { + Some(f) => { + unsafe { libc::rewind(*f as *mut FILE) }; + } + None => { + println!("FILE pointer error"); + } + } +} + +fn pku_feof(stream: u32) -> i32 { + let fp = unsafe { FILE_MAP.get(&stream) }; + match fp { + Some(f) => { + let ret = unsafe { libc::feof(*f as *mut FILE) }; + if ret < 0 { + println!("pku_feof error"); + } + ret + } + None => { + println!("FILE pointer error"); + -1 + } + } +} + +fn pku_ferror(stream: u32) -> i32 { + // let now = std::time::Instant::now(); + let fp = unsafe { FILE_MAP.get(&stream) }; + match fp { + Some(f) => { + let ret = unsafe { libc::ferror(*f as *mut FILE) }; + if ret < 0 { + println!("pku_ferror error"); + } + ret + } + None => { + println!("FILE pointer error"); + -1 + } + } + // let new_now = now.elapsed().as_nanos(); + // println!("pku_ferror: {new_now}"); +} + +fn pku_fileno(stream: u32) -> i32 { + let fp = unsafe { FILE_MAP.get(&stream) }; + match fp { + Some(f) => { + let ret = unsafe { libc::fileno(*f as *mut FILE) }; + if ret < 0 { + println!("pku_fileno error"); + } + ret + } + None => { + println!("FILE pointer error"); + -1 + } + } +} + +fn pku_open(mut caller: Caller<'_, Host>, pathname: u32, flags: i32, mode: u32) -> i32 { + let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + + let linear_memory: &[u8] = memory.data(&caller); + + let oflag = PKUOFlags::from_wasm(flags.try_into().unwrap()); + unsafe { + let filename: *const c_char = linear_memory.as_ptr().add(pathname as usize).cast(); + let fd = libc::open(filename, oflag, mode); + if fd < 0 { + println!("pku_open error: {:?}", std::io::Error::last_os_error()); + } + fd + } +} + +fn pku_read(mut caller: Caller<'_, Host>, fd: i32, ptr: u32, size: u32) -> u32 { + let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + + let linear_memory: &[u8] = memory.data(&caller); + + unsafe { + let buf: *const c_void = linear_memory.as_ptr().add(ptr as usize).cast(); + let ret = libc::read(fd, buf as *mut c_void, size as usize); + return ret as u32; + } +} + +fn pku_write(mut caller: Caller<'_, Host>, fd: i32, ptr: u32, size: u32) -> u32 { + let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + + let linear_memory: &[u8] = memory.data(&caller); + + unsafe { + let buf: *const c_void = linear_memory.as_ptr().add(ptr as usize).cast(); + let ret = libc::write(fd, buf as *mut c_void, size as usize); + return ret as u32; + } +} + +fn pku_close(fd: i32) -> i32 { + unsafe { libc::close(fd) } +} + +fn pku_stat(mut caller: Caller<'_, Host>, filename: u32, buf: u32) -> i32 { + let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + + let linear_memory: &[u8] = memory.data(&caller); + + unsafe { + let file: *const c_char = linear_memory.as_ptr().add(filename as usize).cast(); + let buffer = linear_memory.as_ptr().add(buf as usize).cast_mut() as *mut stat; + let ret = libc::stat(file, buffer); + if ret < 0 { + println!("pku_stat error"); + } + ret + } +} + +fn pku_utime(mut caller: Caller<'_, Host>, filename: u32, times: u32) -> i32 { + let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + + let linear_memory: &[u8] = memory.data(&caller); + + unsafe { + let file: *const c_char = linear_memory.as_ptr().add(filename as usize).cast(); + let time: *const utimbuf = linear_memory.as_ptr().add(times as usize).cast(); + let ret = libc::utime(file, time); + if ret < 0 { + println!("pku_utime error"); + } + ret + } +} + +fn pku_lseek(fd: i32, offset: i64, whence: i32) -> i64 { + unsafe { + let ret = libc::lseek(fd, offset, whence); + if ret < 0 { + println!("pku_lseek error"); + } + ret + } +} + +fn pku_fsync(fd: i32) -> i32 { + // let now = std::time::Instant::now(); + let ret = unsafe { libc::fsync(fd) }; + if ret < 0 { + println!("pku_fsync error"); + } + // let new_now = now.elapsed().as_nanos(); + // println!("pku_fsync: {new_now}"); + ret +} + +fn pku_fdatasync(fd: i32) -> i32 { + let ret = unsafe { libc::fdatasync(fd) }; + if ret < 0 { + println!("pku_fdatasync error"); + } + ret +} + +fn pku_fstat(mut caller: Caller<'_, Host>, fd: i32, stat: u32) -> i32 { + let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + + let linear_memory: &[u8] = memory.data(&caller); + + unsafe { + let s = linear_memory.as_ptr().add(stat as usize).cast() as *const stat as *mut stat; + let ret = libc::fstat(fd, s); + if ret < 0 { + println!("pku_fstat error"); + } + ret + } +} + +fn pku_malloc(size: u32) -> u32 { + unsafe { + let ptr = libc::malloc(size.try_into().unwrap()); + if ptr.is_null() { + println!("pku_malloc error"); + 0 + } else { + let ptr: u64 = std::mem::transmute(ptr); + ptr as u32 + } + } +} + +fn pku_clock_gettime(mut caller: Caller<'_, Host>, clockid: i32, tp: u32) -> i32 { + let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + + let linear_memory: &[u8] = memory.data(&caller); + unsafe { + let spec = linear_memory.as_ptr().add(tp as usize).cast_mut() as *mut timespec; + let ret = libc::clock_gettime(clockid, spec); + if ret < 0 { + println!("pku_clock_gettime error"); + } + ret + } +} + +fn pku_dlopen(mut caller: Caller<'_, Host>, pathname: u32) -> u64 { + let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + + let linear_memory: &[u8] = memory.data(&caller); + + unsafe { + let filename: *const c_char = linear_memory.as_ptr().add(pathname as usize).cast(); + let fp = libc::dlopen(filename, libc::RTLD_NOW); + if fp.is_null() { + println!("pku_dlopen error"); + 0 + } else { + let ptr: u64 = std::mem::transmute(fp); + ptr + } + } +} + +fn pku_dlsym(mut caller: Caller<'_, Host>, handle: u64, pathname: u32) -> u64 { + let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + + let linear_memory: &[u8] = memory.data(&caller); + + unsafe { + let funcname: *const c_char = linear_memory.as_ptr().add(pathname as usize).cast(); + let fp = libc::dlsym(handle as *mut c_void, funcname); + if fp.is_null() { + println!("pku_dlsym error"); + 0 + } else { + let ptr: u64 = std::mem::transmute(fp); + ptr + } + } +} + +fn pku_dlcall(mut caller: Caller<'_, Host>, filename: u32, funcname: u32) -> u64 { + let memory = caller.get_export("memory").unwrap().into_memory().unwrap(); + + let linear_memory: &[u8] = memory.data(&caller); + + unsafe { + let file: *const c_char = linear_memory.as_ptr().add(filename as usize).cast(); + let func: *const c_char = linear_memory.as_ptr().add(funcname as usize).cast(); + let handle = libc::dlopen(file, libc::RTLD_NOW); + if handle.is_null() { + println!("libc::dlopen error"); + 0 + } else { + let fp = libc::dlsym(handle, func); + if fp.is_null() { + println!("libc::dlsym error"); + 0 + } else { + let ptr: u64 = std::mem::transmute(fp); + ptr + } + } + } +} + +/// Define env function +pub fn define_intrinsic_function(linker: &mut Linker) -> Result<()> { + linker.func_wrap("env", "PKUFopen", pku_fopen)?; + linker.func_wrap("env", "PKUFdopen", pku_fdopen)?; + linker.func_wrap("env", "PKUFclose", pku_fclose)?; + linker.func_wrap("env", "PKUFflush", pku_fflush)?; + linker.func_wrap("env", "PKUFgetc", pku_fgetc)?; + linker.func_wrap("env", "PKUUngetc", pku_ungetc)?; + linker.func_wrap("env", "PKUFread", pku_fread)?; + linker.func_wrap("env", "PKUFwrite", pku_fwrite)?; + linker.func_wrap("env", "PKUFseek", pku_fseek)?; + linker.func_wrap("env", "PKURewind", pku_rewind)?; + linker.func_wrap("env", "PKUFeof", pku_feof)?; + linker.func_wrap("env", "PKUFerror", pku_ferror)?; + linker.func_wrap("env", "PKUFileno", pku_fileno)?; + linker.func_wrap("env", "PKUOpen", pku_open)?; + linker.func_wrap("env", "PKURead", pku_read)?; + linker.func_wrap("env", "PKUWrite", pku_write)?; + linker.func_wrap("env", "PKUClose", pku_close)?; + linker.func_wrap("env", "PKUStat", pku_stat)?; + linker.func_wrap("env", "PKUUtime", pku_utime)?; + linker.func_wrap("env", "PKULseek", pku_lseek)?; + linker.func_wrap("env", "PKUFsync", pku_fsync)?; + linker.func_wrap("env", "PKUFdatasync", pku_fdatasync)?; + linker.func_wrap("env", "PKUFstat", pku_fstat)?; + linker.func_wrap("env", "PKUMalloc", pku_malloc)?; + linker.func_wrap("env", "PKUClockGettime", pku_clock_gettime)?; + linker.func_wrap("env", "PKUDlopen", pku_dlopen)?; + linker.func_wrap("env", "PKUDlsym", pku_dlsym)?; + linker.func_wrap("env", "PKUDlcall", pku_dlcall)?; + + define_raiden_function(linker) +} diff --git a/src/commands/raiden/ei.rs b/src/commands/raiden/ei.rs new file mode 100644 index 000000000..0679c80e0 --- /dev/null +++ b/src/commands/raiden/ei.rs @@ -0,0 +1,25 @@ +/// test native library function +pub(crate) fn raiden_add(a: u32, b: u32) -> u32 { + a + b +} + +pub fn raiden_call() { + let filename = CString::new("/home/lhw/wasmpku/libpku/libraiden.so") + .expect("CString::new path_string failed"); + let funcname = CString::new("CheckerPlusOneSimple").expect("CString::new path_string failed"); + let handle = unsafe { libc::dlopen(filename.as_ptr(), libc::RTLD_NOW) }; + if handle.is_null() { + println!("libc::dlopen error"); + } else { + let func_ptr = unsafe { libc::dlsym(handle, funcname.as_ptr()) }; + if func_ptr.is_null() { + println!("libc::dlsym error"); + } else { + unsafe { + let func: unsafe fn(unsafe extern "C" fn() -> *mut libc::c_void) = + std::mem::transmute(func_ptr); + func(get_memory); + } + } + } +} diff --git a/src/commands/raiden/mod.rs b/src/commands/raiden/mod.rs new file mode 100644 index 000000000..1718f2b3f --- /dev/null +++ b/src/commands/raiden/mod.rs @@ -0,0 +1,14 @@ +use crate::commands::run::Host; +use anyhow::Result; +use wasmtime::Linker; + +/// test module +pub mod ei; + +use ei::*; + +/// Define env function +pub fn define_raiden_function(linker: &mut Linker) -> Result<()> { + linker.func_wrap("env", "RaidenAdd", raiden_add)?; + Ok(()) +} diff --git a/src/commands/run.rs b/src/commands/run.rs index 8185bf7e0..9a796bbc8 100644 --- a/src/commands/run.rs +++ b/src/commands/run.rs @@ -1,5 +1,6 @@ //! The module that implements the `wasmtime run` command. +use crate::commands::pku::define_intrinsic_function; use anyhow::{anyhow, bail, Context as _, Result}; use clap::Parser; use once_cell::sync::Lazy; @@ -180,6 +181,8 @@ impl RunCommand { let mut linker = Linker::new(&engine); linker.allow_unknown_exports(self.allow_unknown_exports); + define_intrinsic_function(&mut linker)?; + populate_with_wasi( &mut store, &mut linker, @@ -313,7 +316,7 @@ impl RunCommand { engine.increment_epoch(); }); } - + // println!("before RunCommand load_main_module//////////////////////"); // Read the wasm module binary either as `*.wat` or a raw binary. let module = self.load_module(linker.engine(), &self.module)?; // The main module might be allowed to have unknown imports, which @@ -325,7 +328,7 @@ impl RunCommand { linker .module(&mut *store, "", &module) .context(format!("failed to instantiate {:?}", self.module))?; - + // println!("after RunCommand load_main_module///////////////////////"); // If a function to invoke was given, invoke it. if let Some(name) = self.invoke.as_ref() { self.invoke_export(store, linker, name) @@ -384,7 +387,7 @@ impl RunCommand { t => bail!("unsupported argument type {:?}", t), }); } - + // println!("RunCommand invoke_func"); // Invoke the function and then afterwards print all the results that came // out, if there are any. let mut results = vec![Val::null(); ty.results().len()]; @@ -442,8 +445,9 @@ impl RunCommand { } } +/// For env function #[derive(Default)] -struct Host { +pub struct Host { wasi: Option, #[cfg(feature = "wasi-nn")] wasi_nn: Option,

      2. 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∈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 ~1*%nno=KUIZ9%||m}o^*8=jh5V|;#oM^U^oz3 zG_0aS8xrY8eMqQR$3lF#0AbU9lRlr+AWr-R#2Ja#C`Vf))CJWbS%i1X(xGW8XuX_7j2T+F}N=*r?DWxIlu@T`pVPE@nHt}j>NA^rV zvV_obYhHEtR^8LIdrzzHm^{bT7Rk=!5(3p@gtsazehQYs^Blai`toNkUIOsqGuNmW zJTdic!AAm`B^QCBphgHBISeNDVl_FB`j{YVRtC7VUWu?WxzoJ39;(nb1U>3)v^3#nR~VHGb1i)2es&3V1P6bCZWIC>6s8{>s8VP94hB^o{TMkZ2p2$!Cq~rnyB;n7hO8Bj1zJ5 z)T7>h`d|J(`#0^bCvU=>O{Jr$ZhZ5^s()&t|CR=1)h;c)^-aTFHUk6|1Ry9Zc#`S% zEapH^ZHu?q*Wrw^=y~{sJR9uGE^H*N>}WXE5`*slOh}0{MI|)qVoc+lUApvMJCmcv zOvjzc6UM#s6u3;*@SVvMZ36JXU7QRVHgwxO;;ot5eak(achVZ5KTrdluei%R`cs<+ zIdfIk{L{zzUTa?y~1spLRh&Yt?o zd-UI-rxo8-9G8)H_oND+N%BCQ%JO+@NK624VN9lLJ>jfR?*2_`8v1zM{x5gG$hkx|&CkBWE0~o#m-_RV2eaTHp{`)jDyoP-jj`?&nvv9@aZ1!kahI zAA&UFTJt$29co&7$R4ec{hRAX4Tzh051`#`xC0o?dnNWY48OPPmpbd`sQn@`i0`I*kW@Igl~cFG@Qjfnu`;>7Sz!PLoFwM^?NIV zo|P%SC*B(BfMBsHs}j$`${;`FTjZf4-CXe=J+-UO@WBcB1wdLntm;74J5O7zGkjZ@%y`DtrCU@42JvN zvEL2??8p+G?&F_ySo~3MN!(NY<6BuPia)-ch6pjP{jS6}sRu#1wv<7cjPyXMasM<0 zxGwuNf^Ny9Kgje*UY24DqlOlb_0KpeDKphls&JQhy5enro-3mJ)g#H?kidMdaEC>C zA-x49LQ5PG>{G52Tar0SEs;Y!NubUUTw*WXvev5YUcZbD^^&_vhrjhDy4vcndPtpO zXHyv413)EGip)o-Ol5+ZH|asBn8f1S{-RxJKFoJ(wK=z(U&NAP7@b{#(b;t|%JT3i zFlwWAM2v=(en^aR;sqym@UF1|Bdg%_O&><4sBvnCaXZz!Ui~N9p{$nwuODd>oeN}+ z(D6(lObf?_Kky#Ez*CAdHa&0@Oiz)yvH<5EOI$_=9iSwkxK&d~OFZUEssL+KT=|ZU0ET9ibb%6Mmm;SX1ep0i=RDA5Vyfqo@ zb}jm3>%=E#YLRSQYVcP6%mnFt|a%ik~onGoHx@CxM#`RZ#O zx#9gm`thQ0+-9YtIbZ2$na{o)3aG@FH&1S$v^7nM>_m&ZZ89J=ChIO_WqHp>VK zXKW@Ru?3lJMxsw-Gl*ASa#Ch9@b1-KkNJFvUx`}}=^c6K)=h9Dm)X9kqz9XpmZGpV zBM~Y#VnE#5e7Zf#N;KW1BEG3L0d%-YMSLTIh^O=Aprp3j0l=iT!+Jn!dsq<7R98xB zJFuB2pu8pgF6)=_NNd>ikIz0A-tW`z!wn?JXR-MM&ExB%)HVaEkIxQ;!k260s1)gK zMpD~DN{5?W71EInbX?_Reh}7ARAwnW&Cw+pbNloTp846O9~16@{8(SE!=gQdYX#*P zaA`f@a?5Tdgk%XQEy9XHCHO^G`Z1N=*=nbemS(DZwz#-tJJnTcZHr4of(;<(3Wvg3nMc)xS)yLu%~LvAhCwd$dI;uJZzj0 zN&@a|8*fIm*rfB%o63TR;*5pG@fJxpo69X{j5Yy*H&z0Mcy?-O*s}5e-Awm3WBa}y z?t(x`b(9%zk^>yzg%T37HmMS+#mH=KG7>(Nw#n34WVW6S##{G*`$Emnlv_(3u|PRT z%CC%~#aLr2A(cO{d;T((ZK)^r_|TRSxT~4a?aWO{RLffsdFIR6#fUDN*@{)2fnh5W zL@Y!4@|H2aVX{s}XN%YeOx3U@wSC)`CU}^LNWC)R(`Iv8q{21ZRuT0?RZ(+mGSVH@ z$hmMVP==~*94dKT<9mj|`)KY8%T-twSX-NX+3Y%2wLw8y62?QN$b-c+eCF4jx9WG< z(9IdkVlNqTn0i#LKbn1pH6iw*}%fSg6_zI&^*y7VGRt6%x3$j**(aD+rP zEpIU{BBU$>#FTBsGN8Z*$ko0}9D&^R!~ani*ZSA0D3(Ry@vKnT$qyFeo}Oi$P(!t! z7-NMkL6aAwr+IqYgR36_YZkvDKV#U#NrHp{B9GAC+rzgWsv(_Kmv0e=V7~gtv>a+Q z=B7wBdKZ@XW0A0Wb#McvD6ljqvIxhbU4>;tg@hbK5x1HK^lB$zoHnEy(`_gqSXjXZ z=P#u*i*^=~`Go0^(l$8t1#JVOMbtK!#_mNcPMrPi>n1dI=Wa%|XP7%QpETN(Dd{Lr@^%Ow9i1?h zRY#efAy3pa=Cr8|#)Cgt%~pG)NyAHpO`zvaP=2(Im z(xv9eHK0MwfgnxTg7dIJqn{uOgsVA7&>4{lHAiTJO}W76#5SUu!yGKLpx_|TVY*ie z4%Li`rj&5Pf}tDChF7F!xeBHn#S;{)gw$-w5m_l?qr=OD&&I}CyCbg>-kkf%i^jDR9e4;c{b`@2IAE`{8 zW1&<>{~1VdXhWnKSSi8)D3wnGITZR@S4&u!OFL;nLE=<^21|`Ot*AShP#am8U9O1X z)D9?tJQ&uwO$WrJK#K}Xg-*(E& zpmP@wvN`ThY)mW@sz&js3?v&$K`+yV$tOY<%aH>Gh?Q?9^Gx~NjnX%>Ods=tj&^X| zrmB)GKPLhi&m!CC!j>7k7HvF7J$}&|W7yI4EYR+m3%XVf`Q!rhhWM|dRgovFND46U zZMQWNujLo)E$5}h6LZ8HR$f_iNOCB7&ZjWuM)@boSU8st=UP*RVS(DMMewTBo4j6k;EG_;4)+vSwt$a z$!-bSoAc4n;j%l_DKc`MtTq@5dDjX#WT}|6OE1`KKNo69;k3+L6=wN1K^Ie*I)>Ol z>N9lRhYqY;Rh+kELDku?;)9y~qm7Ik1j_rtW!|4Y-{WKh?2C?Y7UD!1zpf zKe<bSE0$;A;Nm)y7i{$|7%S47W@(p?;^30D?brgX8ppK@w!{O%0X7}m zgo$GAF%CW}4o-t`@V+k8TBSBoo^g_1eW6yY4-T&SX7`k978bPui}3>iXL5iobmq%2 z9K*V$lE=4R@;qRo3jIf!?s&%SXfPaJ(F(YLYfd+4I(@De3Tk^Z*FI|npeo*OOFX7FE~d@ zxQ0#oDMMXHt8hZp@37c5#Wq+Z5%9%M6SGL-kO6x#$8~o7AHAKP8eM2rub9W$9L~@Y z->Uk&w}ppsM!csotJ&oP}ah}P^N8~u35h1$lUk4vpGk3UyxoH1}TsNMne|+49zX) z^pqBS;h7t@_hX)rdh{qg<;Api@Z9Da1zr6Y=cAt3F|ZDYtN*g*>c5v0g>O?YZ~p6L zY0?!H+%)zm8dsdVzf5mBrM#rn;|Fin9yxQCtye4L;e$#}m8_a#!#Ej=_uLW~> z?|-3ea+9?SZs-Z3MJjB8qRvg==tCp9%?Xm_NBZgxKf3O*{}_4#HO8K;=n3my1XDfn z*SaS*&&x;IlYFu#iU?P|?)C{{m0X7}GGdU~PDUwxgT0+B{6yN^nfwP{`Cu-)P3kY0 zSyY1IC>^e#(abKWjJbmw?E1voY5wcwP^-}Yl+5?3J|HLqQ(d*$f8PXgJqi*D>St|9l)+vwyO2c9mc|0YX*q(uDx)zGUiKMU5{vucX=M8%I~J}UT*vw>-z z@GSHt6IAT4H5F%%WjTne4fgJ-eq(W1 zhz85W;u`IPSW{TiCliYA`xid)KUR@bhyQvy%T;oywC^Dc;>z$tgU*0(@#%$W+)3ZZ zVV69t6}jVzOKFJ0$Wh$t3htQU_%I9j73`o)D>4BX`x3!U;CyA}@8$OQ0OyV_6@;3i zO{Kb5D3^wZDzP@5C>`b%LC(-K!3PI%QJ<+cNj^|^yd|17T_>-VV%^Q`%9Ikdcknx~KgPnr8K z_DMoii>J){vN$lF(r#y}UQNXLHI|b(v=Gw}qU4AWPt~M_aqd)GRFkkU>b0JT9h-=A zQw!tV4X*arGewYR?Y8Hr zeiwOLAVnnO(?rivEuUBSrBRsd4*Oy=T&sJ6W*)0Bhr{Gfw}LBhE}-6Xc((JfC=ZRb z6<^leDBfw&tL(Hx^XJK`>qZ^a)O;1^vi8FKO`OfG{XJB=QMJfDqIggu@$h7eL?U?Y zcFrUQ?V^4J1M;dhI^^eCtl1b)EE(R_iGk_4QTmZb`fN1dg%-Y#@*WpSL878+!OT6G z^Cop*oHyqZ5vD!9CJK0hKiFmi_AR{|@+(gmcFM=qZv|5Uuhf;u z+L}1C1Fqca%*~^hbnP{SNo8RZlP{LUf0Q)<{fBR}5G<6T{nw-CYzUZ=H_XyWesvt*GZ2k zRu(5K*?Enu$Yr(psl6b6Iayh(MJF!6P_Dj_l@XVxSO;lcWYyC!G*AYz;$ux#mT^@u zMOKdj&a)sP4hZtoCM!@@lU3iy%809mS!6{Xkr!LhKtW+tG#KNW(ikPIzN-Y*tA5I>8jdtURzKxcKjl?FQM~FsY;in#;E!6ak_^Pc zSbRfr=93t9-6zn|-*CPuUa7IVWU#utCMNFx%8sm}t=mI7x@Ck0!a-pRb{}v2A{mQX zv<>EXY|0g*eh>GDv~p`viL%P-JU;vJ$q*5ReM4cdg~GlGSC4fS3<%7p5SSYRxnR!C zuhXo`Op|iNGit`ItRtRB_ZoT~L)M!xiVjHKb3N6Z$!C2==Hh;p&WP&rb zr26&F%EO4I#KdrGx52es6VtFIN#mBpbd|V=#4U-NeO0`UaU3B*q(t_bJb0e~m+jx` zOv&)*q~OU-RZ&CU_!0cSaOUgpFD@R`tp z9UOC&Y)tm~Xnv$Tc(M-uTFO=mAnVEonz`<3%`4T!-?5vSfqOb*Ycvca>hW5Pb@1x zw($8}x_4|y#g&2*f^7Q*$ic%3jFKwl5D!L;B$gEus9&f^h9%uM<$#yn;rE<78oI^+ zW{ykdh(R;}`DlY3hC`8@wq>@ZDFb*Kw3GQPL_;9QXGez-(^eWx78}uuPy~Mit1qj5 zmr<4JPR-c(#$hCZt?3RRbEhPgQY(QxaDEFtRK02w(f??V18NY{AP15Sy;34}C=XNv zsSOm)i_bIGl}K&^*?JTpRqohC?3OoSJwS8sh_|c20_xdvYVghW>5sa#sbr!h)?wL+ znd2YV7($(TlL^oikLg~he>j{4GAH2SfJcCO`tXdPLJ&X@mQpp>8oEx4qCSZlio1S~PGX6opc28hxpT$^ zOqfv#wQ)#RC~$iiOLTP@TX3Q=&#I*vKW1|Cxd6cXJgE89dkl9|AHDnm#i%+!_sMX*oQKY3YB;^rFAk&bP zfFwDEYLH0^@$iHskS8SZCnCwTkESQcrhHx-mm3b}Nu|b^4}S#;tI{TPfdlF7GI}09 zAa(fxMO7LH*vS3)=V{^s8@p;F!MRZH(ZdsJ%C(4sg~xkR%&b_0NTT?vb1-gVHy-;d zL;3_tbZ)9%^MY+m|U=l8SFy8tRfSmp`V(wPcYm zliq)cY=`5O4~ayMSOA?teB@9Tvv;WsS2VMLCX2=A{qAM!$`zo$x)QN64L9QY;3kSRu8`gDS}b(hu|rlaK1rQ!1R#V0>8iRWprH(h=DctnK+*W>8_9@tqpaNq{4ui z?ZH)#OG~x(?=Lbqhqca-hA8&X&LDVJQ(}iTKn*)oewU;N)wio%AGZ`*Wm>efzN!NE zxTbna;f!wVZHGL#r#f{Uk`?LHn*}(P-{=>1XgaP4V{~N?HMCo}k|;-$fsoX)Mvl70 zJ9Q=iNDk^m_rR_FW&hf7gC&aHTQjx9Fu2ctmlCU%gEHqF(lbE$s<0jTnDweXbP(_0> z1KdP3DAJHY6b;I%plA~fDu}wW44R6xIRSEzMOjmS>@et-=jVvoos{T$RDRC#pI`Ey zQ}uH^D70@U`VYdYW=#;ue}lx!qj@6rsXB8)b`F`i8z%pC&wM^VOvSV9Enfm;RdF4^ zYV`H`yS?I;C)3l~(aHj=hZD2u^wCTM9 z5N^Q}jcI;!8Bb^`Sq+dR0h$FjQ0?!9!Lz0ZX!+6g92D{a?I!-u4b>?(#@eFyq5$vSJN94U?vhF$=KX!XSV+H>cG}Y~{L~8UiyM@#0R$|s`ooO5>65rlCZ zk#vt0W`dkC9?nY`#*6p5Z%(#yoUJU*%#2HMwZu3vSreNjHLCP}0`Wsy`-{M5uP(fG z37KkhLXHwx!L6>VY!2oQKatsey2n$N)b1zef&g{BmTa}Pi?e7@2g06}U?3<0v%~bJ zg$l_pK%_SSGx^jdJnIM!Lis9voXBR{3Yw5K%%zuw9Qu2jZghr)SiNTBah1B8(Hrhr z#6MaW#qk|DoY=IlB`Ok3DlOh82l6C81M zj_h!8P9Nwjz9zdd&7M{O9b^&*CGM5Iu#W0QSJ@hP3Y`jnu-ohGo=+K3w^On5sj!Qj zsl`|wN5g3jpT!Jn9aeSb^Q?Pql_Q#U(WhG_!SA@{o#?-;Gd2`PlWb_95xXdI_)XpH zDbV~M(=ePk1(B41DT2Cc6Y3|ET}VZMAcbwPJMXki1B?{KaWt<=9v;FQ-41VXt_YU5 zK+xvusb{haMhrAuSY1e*k{I(dC?Q9uGtaYoLClHFsyVr-<>cS45-MUJ%@9#Wq4io| zhH5$ch|be}Kql|7f_Fq05Zn1{`E!z?Pqn14yDFU-F}}f6-wkF7u@VMv5X}^Q8*~1I zq3PSO^T*$8H z)}tuW21q9C*{PjIfipVIE;-GsS~4Fu)F0*5ooqGJJb0_|U2`<#QzXQI34%CaItds^;`#mmYwvTY>#+AQ`!#ck7h^S zW1m!}v?cwtDsw26IpEK9lrS?C@`S+v1YXh|&%biU;a=^xLHJdfoXJzV$B9g+1A`+Y z5C?p)e}`Onhmoq-F(}%Mn=gmGX@E&Fjx95y4FHeA{|e(@V-l9ya}$hOx@;9^yv(b5 zEUywOe_0E!hW|K{ODvKr_sk&@i;V-j)u1pr=JPV@{c-hfT{SA>5p8@jXe!6#bB;Ud z(Rx9tVl)8K7Fwk78?2utWW5a+y!sS{lF(p`XBN zVsha%2^uwR>gsb|WW`*R)@XhkObtMhLFUS~;I$NZ(i3dsR@h52w$MB%j`6b#&HK#w z39Z@1UZNU@dGaCORVaB$TfbeC1xc=cwKdBpVOgg9PxzIf8h_sxyA3sBZ#y(neJgHJiQqQ7t$mWtn30T-Es#Xbzl0ed*7W2(qCH-E1P0b+Pr`x!CwDM=;m5ZR{C zMn<7CeZ6$w(GT!xA_4L1=wy6U2PPxN)Jtpe^Kb`0Co_IpoILX4aY9^??oNJ#I5|mL z?#qr7I_co#BxasYsPAFKV{V!)cNfh?n8Ll!Cye#qhEbGAD%o@ zcJ-JXefV2}Sp6APpS0_*fEN;9{TKg|3aHChln)YLf7GF7D}^Xb#!Jj06wu;}9qgoF zxJayB>k1Kt)N`O%_C#J+U^bSD6xtQ#_B~n5?UGA70rynkPEoVR^G=A#y>e`!eIYiA zf9cQ-stve_vaPTIKQ{7c<8bA9kM^$q%ojzl?a}^b?}c32h0|PGF>>~dAM2gLsRcl? zBEnO)OS`(UOG{%By+-LUoU{3~R%solmXRxdfqNK6g#}J}5SPReiq>5Xl`6^WxU0B^ zV6<58t}6BZh22$2s>3G9UCsIDI@m-0s+9K&IjkN}@>m76z){3mvvS8_m5N4LhSb8w zXY*JSlGl5zGbEpr%WA+*_gVkp<6Dvet}GK{DO^Gp#v7c~bx8FXQHK`W?Ovq53^!VM z5f15Fw^KIapP)!iXxYC#sR^-vN(Nl@LD>anO;p1*(;>uV>OkD(*ZD}J*T-EOcW553 zbBm?L*Ryk(=HF8bhj@MPDmei0uNAl!7c{)sr)+C9j$L5v+8){_S!m>HHd;EbDnxekiWLsob8SFbAf@U{lgylZaMa#gEeOMQex z1$5~d%E&Q|5@#)@-l>TKSai0WsnUU*0qD70Wsdpfij@To5STF;EvK1tbor9rUU_}o zUS5AYyJX93BuvyVDA~v$m~(2gLAl#A6q5)}S}sVz*FhXdH)+hAf9 zOZS?t_@D}&42|tJPc?j^!eLv zfG}FPT1(tyUO;f!4tg-V#kx)QDAa<*UWndyy_S;bNd$H$uH-lswR$oBGVI28-Ml!M z<5E-XQm(_$8_-jME-`^16d5&Ue$53ZmQqZX`|2h%mQmNLjA#Z&Dw;9s_%-jg&NXAS z%yqM%efT(k2)hdFNM5WmfG7ND$*c@MXI25p9+BvNvTC$Mvs`^dY6QZ_oh0SZU1|z|iagJ|aeeUD53{HVD?0arjA60i3 zW;vf#!K5~ce5fovOlT~gS5K*l8KVYBf}j3K3D8F{5l?rWVgTp*4DjW3dR_uBQoN*B zk5rn3Y9lcYN525`5rgURR3A&U+uR>jYhS&s0xi~^`lBssoeAVAk{>CYZhFa7oRqo@0CQ1cIFQjkgMz0ln!UAMF zq+l9rn=nhmbTm%M49-;;=Ou)Zk{L#k%piTDP{=<1@d`SoNyv-kUk}fRhUR)DE8c z3q3=dKJo;84@D)esS@)ige@_QO2}4^>K8w#)*D16G$4stsD3@33#|_*S>t8*$MdC> zK)64l4S}e2e{vXtA%m$)r4*&FC4$(_)KHLVF7t*q!YAE;_t&WiS+^|`1qlmpUrX((61C^5Ye?U*4@s)YSj!!ADgKi&prTJ7x~#;T&;OaL%CWFi>8?%BEjqP-Pf z=liEQtfabRf3=|e@|FWJOp3C-WJKJ(o1fQF2L3}^) z4!4)r-^Nc#MUn*>o@lHX)aVrHeS{L=J&9c5WjH4_6x9PtqM1Ba=KW&DCA~cYujh~^ z_BpR2Tgo5Q6j`_5s6Y0+&6bp#T{4L&U5Di)AN0sKDxjoC9KI14ir{!%s0iH_a^yk` z!;T@SY#@}T@;w=L5=BtEEJ~BgfIxa(f)MAtC9D7sah-0>MZbapsku`P0vL8cq2mZW zB-RNE#+B9qG(>*4>jD~upvG_mdwkieu#t78)p*V&(yhy<#SvO3s10pp;6}bu(HWTC z`lx~omKj?StinJ9H>2C9KL<3#;zbSd02POwi8NA?-{Ndyj9x6FA5zH>Sp+^xx^xm3 zU=KhGDK47f@hPcfNB)%)DGKt+jyB{;Y?MgB1a>8FB7fhrPKafWwXF;!#6>5OA`3BR z-RmpK%D*hm?6T^wm{qTj)#I5Av21H$3J)Z7ffB!!l3)yrouLkGF}>=Gmvp(GjZ&^T zsw7R_N>R>op8W4V_BGy*c>~-<_snV4Z)gs^P!On2xRnD&m==XKh@XnPxv}7!^w?nb z*k@(&W%+GE=y^wx2bY_MrxGL*YYk73=!45(*BWEiTW+#9dCi$daSrePr?C$cj+7(# z`_Vg;r6>00!_t6hHb(_+VN(jP@f<6I{J`1-RE=7|61$OIgY0WLFVjE^y1p$WEwcc! z+$=lGQy1x_2<_XCaI0*2A929>rl<^c=G4iR_{O?#5qc(mFCP&PC}vdD%V=ynPP}3O z^g0S^|1$P5T;!yeb^s^^RChZ7t8p4?2Y^kMm`DSN+i3tRXB&W_)hN=sngUug7*}R6 zLT&m87|Rw$bQcqSLh{A_(Za|LaRjrXkjyi?{A>=N#%*BKFj#gG_tI|0@+HngXS7ULVo5$gua>!S9n6-9gy=wtXR+mq-8Pl5q9qHAZ!FUn z(;-)7|E|nZ@gSgw6K{_Qv;~1^?2tW9y7RI%BiEx>MaW8iwxx(wrOS%f$GyW0FAf>@ zAjl9^N!M20>V<1~a_QB*H-JWdUCoZWFUdivdy@m+*##yTCcpV&?JM0E`d7T^#TDO` zc5A(htPv;IrA9y@jdb+7T)tjul~OC}E0?dITt2J9nJ$&f*9(^qRWhEk?Ns_c_tEZ- zne1shOAx2|q66{VneLNE`)PxCWFG*jEv6d9(%kYk7(RQ<;Rgvp z3A;(Hx4NI_HLd7lgPr0V%{EexITWtm-2D2@-_dtEi_;m3# zeYLXK{9PYq=}7rU9$`G~ljwj&y*>YLU4CbOjI#K_Bb#2mINA6g4tPAvKSenhg4#** z;7vz1m7}F0=fp6KK^y`qFx8`F#phP`rjvuyO@KH-7ZFNfM$IC<3FWt>(X0`%;#(Yt zN)qq!dgYC4tBhd92NLVh zjp3hzSQ2tORNw>&QKq@zc=K&P*if>6@%XVft|^(?G+AuUyAr5G40skK3pM9Pi=eVw zhmOyxcWA;_`r(&w$l39^uZ=16$A9qx6nZIi(ISLSlVgI`x%JO~J)FwLW*gBh1oEtO z7%o$1+;mvk-&@*VZ`}!cn3wNkyf)JrjmYT2kjx`dIK6PLD zZZbTu|9cEdbh9xj-u-frqTZ%}z+&_DmIf&_a8?=&>|KI3(LsO4(?zxDA5IR=z@>%6_@t*^D?Iv3tjWe+p-+_)68^SHi)ac%dw z#%CMXCti+m)!YB63H8->K<7dz*B{YfzUh<3`B@+)FUO=2t#2#`pW*bBvrigwOi-52 z<<)$y%p>&5MSPr!ZM+1Iw7NzOW0}RNmdd5o581{&zxt${{OL+_vy8j4#`)APK+OxM z&pukh*VXRClbMhgC0x&b{dwo5oK3-XL1Q671{sObT1LndkZMR}=0x5sdsAgrX@pu` z(45@tV~&r&%Leaed=?!%y7uNj1D?73!QW-@!ae_1w%a^SZXNSAID;0 zK`^8@u5B_C6nb@oPJZ%%`A*K^sf}!aZ(xQAb9AxZBut(S`z@A5O$LRjwS?qlDo zq@>cj-PRH3F3EkZenKo7L00`%TIetgcQ~Ar=Kz^#2)qr8V{XZ`$4u7lT1+q5<=gyI zhBIq^YMnEYWN8g3DYEaF&ac3<2RpZeX>Hs<=ARqr9Q{ zs*adjIMUp6lboV@%#kRv0%aQVoFC|)_CPfH+iFy{ArQ;B7CaIf!!Fswl@;I&ZeT{x zXfWDv=Bq#Sc2ORx{{9`b(%c*e!l3Th7Hu1W7TumdsWt)b>4sY~vJNIcb>3iG@;H*G zbPuQh4YI?*_~mH`*IF2+=v%uPN=R!rDLbz}qUr<0C_RNE#tC+MkSMxr8@}y1k{=`F z&RR`w&ySJl?8CFQMOhD%#;Xbj`bv&(ZUT>a2Uo}dW=%;u7b!aA#-pw1m81c=)-@m2 zek|lRPvcY*;<%b?11+vgxNlAA-FL$u+UZAXwAL2oM=8SqAQ=u3rCvLUY~uSW4i=4| z__XNB21XF&XiV?uWyReJM{~tlwc}}ZaJm_WpbAY7^J!GacG9u+6c6g&pxz<{G~M!= ze#KWgThN&7nvdAo65G+0d6qAC7t<}gw7%oDEh-PZrTO@0Tg`(8BsvegTN3NSU1Fq- z{;db!+1EY>`D|zM%_yRLmVa>BM)21te71$9(UMfF^AvRSBHzFfSgZbvW|$dl6ayPm zgDMb8Qo8n|D%D$9L{JFkjcP1UDvHHp;)6FZFs^8DD+|j@(5K#%x~d-c1UA}rt(^yQHuFE~Ai0z0)!Z=Ew$G@>8NYV*NHf?DX`mKDKRRA- zexnWOEy>E=9CVzyGb6b(n$JgaF-LM|Dn4*$;DfNDQ-7m_Q!aR?4ghcCAvt06r>nXB z;F6Ku8Me6|hg>svW+Z5$FBpd7g2k8`%Mty>~f}p z>SXKeS8x#HPz?t?VCdcebk=0Lz#);`xcUg0#o4LR3(~WCNL2K7d)$(tmHK=_eGpb- z94;$^L-Mp)WZAyIx3&ZC=7N?i+iPx&r&|I|TO>>j7|gV2g1q6~Tp;h}!rST{x30;! z871QEz`MC1c{e=i`Ci`5&P<*Q*Dk0pY`vQo?htCFrrq3hOY&}jY3ALG?A-uLbOU8L zl}?n=aE|D&LIEA4`Q@cda&@|tsdw(LZ@(9E?7SBpCo<`wAX6sK0RKOfMi6PH-L@px zM;cJB&qdZja(#Rl6%57&tEw$YL3UjqSsdR~&Py(j6c2(U%8JkVt`XE1J)B0U$2yEC zzqX>Zp^}j^IM(b*g)>O|K^o+DFvxH5Ams<0agd*wk@TBB$m9l{K1hwA{+3^zUYIC) zVWz0wm{F9mrX|u)&ef-^G3ODcC*=59A+W4POv!{CtNPk*CR~mdF?KhJNocaK%8)AG z!CV|j)XMar`mObiOOxnT%w~wQ9D1iWU5zPF2W27FoSQY>tZI$c6!f6Cq%_poX7;FB z_msLe!Z&Do%`ZKE+g!N~XrCt^a)mxED5Pt)tZntQBJ81X9%SEH?LEMGD`#B4Ro55g z0?l8)n#*(9Rq^0bFq%bT7Ju* z>2kf<>x0W$^ylf$f`6U`Lh;l5=7{uTu{w+{!@AzQwgvNu4pGwD6R4?-%j7*MY`sPE zJN63`zKdRs>CF?}pt+|wk_^vk^8B!^qaaMN)pJPv`)=>+vV|ay1aVW2DLpnFZyFT6 zejlb-;9x!M!8qVnKQO|*2f{2lmdUEO#+wRW;BkKNUl@`3C64oBHe&TCadLW52=Ev9!FX??Vn(fuX2U!<>VveKAOFl-@I!yji2<%giuZs$ z|MPJ{ob3oc{6ItL?I{^8xEjP2=Q8XPj|#Lc=(f z?-avpF{qbY47#PjpiLwOz7B)v#7@i7hm6x0bh~W1JO+F&PD)1GL6;t2XeBL`#|$!@ z0k}?-TQp*Qgrdh%FT#S0uZ?;I&Qx2XJFo8Pp|tfERwtQU98aAQk@80GNP`LS-ui0N z`(1gSz=#@Hi29qg;N67|7vv?%L1!?E{c=8)10wC5Wt3|Dsyub=|Yzh?+CI5%^ zAmj7kbOC5bGK*OCx5!zjBH0+NVnYnwZRZqW#9D*;a4*lwn2ihCBFn-DwKYILL(T0E z4=Tab67BXS%Wi*U{A%Gtc$QJc!iQScpybwu+Qx?zr{c`o>fx`fp4kFOXduTKCFeW@ zJBP3<{@81N;mMW?tAficm$I;71VRO||6J}Eu7xncae1J&*S!CC(ELF_(tx@T#|r0~ zT_PTgOeemCz=8q3|k!}lO1dY!oA7;|DUI2CoZ`m zEpfdeOwjV98_*J5Lz!!!A}X?(NEVub;wZi5KmKB?CPjJ?|C>*$9Htbt?#R?41uFWJ z5TZfHQ%`b(gAPF62I3|evWbZ>9rnliHiVcNG z>9tv`QEcsKqa+Dg6%d4Xqy}R4Tqe^_S9?e6ajYeF(H~{JzaTY9y9JXzy#bV_JpyqJ z!K&vGekAQWWBlvLuWESDb)Y^|AI)z(*v1wtU0%>HUoN6}L!&72@A~8j(_miT>S=Z&Y zK1jnh(>xqGaybP}QN?7dl#{Ov3LPbz06al4lVRLLQN*m-sw?QJpcyN%JuJDj5*yb* zvT`}|wVLC!$>}`I8yI?ir1~?R?R6o9<9%J`Gd=FuiZA8$TpV?3r|cm9rYYIEMAz%% z)xB%u*T0O9H(*)-9!ctojCt9BJ~7`&DUr;g=gGL{S%P&+jiHIx^xwn>P>DTNC-^Ih z@k)E|UE_m`7dwQrmv5J+u-&k^^oZ(-pqib)07JVCH3NqA1O2Nu$Opmzrsvca+E`&w zZ(+@ko{W`@-2jHUi^$NX_S7CQE4HwK>gutG2Ep`1m#>FwaTR{^opY{&?p&%rdu3Td z1biJ;H3YYq2&&tpZ`$plGfpF-2?fUS4Z1Dp8)&4+BdBIt(4Rvwsu`$Yg;D9&9&QP0 zZ8D%RYB!5U7q5r!62a!V&P8T+;eUbc(d4^H?P=<@zQ#;z<}sboQS^KAht@^wGd-P> z$Lu`0zpvDwzTdm7C%VzX?#nocao@W3WbkqqjJQJZWj&oJuFO7q)l@!pdZ^!bo{KhL zUTCZ4h|gkP4~cL~{$1}Cy-I~(B}=r9IP_c?w%|6u5rz2O=hoyaO6IA>WIg&5YW*GQ zX0lBXE2%fxyM_ zy9^tOm(YA@C|%(x-AqmC=dEp%(qa@KpTb!zDCj|J9P&YwJ}YH&7cEGAKzGFG)`CZu zBwUlMwuj9#pHBe84=Z{OlURyONr11U9>d3e1m@Me?b|$n7r=K1{fSz5lPi8amzMZn z8xdD^yJTQIOkxM^piMosvtd=zvC2G4ka@Hw!%-D9z=@ofI_kjzJL*(JxD+_pQ6{`Z z>gfqGm%w`Um(u%9{|92r*ksc}uh2g|d{02Cb?5~lf+biC52#ee=8>tgd2wfWLa+eS z4mPPJ5(6Ztn&$KVcqtU%aOkE@kAR~8& z@JX+_>+K0Oa6t9m+xRi1Wk4q#uuphre4I2g{5saVd5gxyWK}eKf;@s2(%Z}ITEk7v zi84V!W4H2Hb9>1uTDcDiSZe#1KtEp`seU@a(3IlDOM1^25T##N$nD*NNSv=lX~c43 zF*+qFbI$HyLRrRngZNS% z#@`-|h@tGf};oDd`!ik_|8658=CRx3Az{ZcU$pl%n7R96LKhefbfrl#F?0%c33o)}2-OIE zVv`ezJ=B`QHj^CTSV|F&$(f>EC>k@ikZg{4_S;@niU5jL-Y)RGm(y6Rz9`f{$e>4H zUAh`{BkVvT^#wS7Z>iRGAr(f6H`l)xijI&(FuHDMVo#Tj=62-vL@R&c{^wgcI9-&? zOS0A~Ly-w9R2&a8d!Mn%jk`F9C76RBcNPNnDc%+imm9!OT7t?g9WAlb+*()FGwNTo z69~MGh&-vc`NXiYenFBEH!bz5#K8Dq)-)jrqR*yDk2A94pB|2m8@s)jM;$HP8j&}n zZ=->Ob_K=i30Q<H)|2@Pusr3#X#(pH6IoA?BdBL}A|bg`7e zfs!OiFrg`xxlq%R7-a?%99#;Eh{n>XFf2@}`Ds-zrw-(hFqs@w&Zu_hFyk`u)@hc- zEbGr%Ron#H>!(YI^d-GsQ#-7`ggT%d=12`c{ko(_PKiPt-7)YKP^Hn)*tohwGmTzT zX0Iw?VC0h~>wcIn*{_!r9g{4l$)+Dy>&F|?52p6r#dUg9*yvbpSXFe$MXUn8@PwpO zCK|sapt94%@a<0WVRJ`$WLJ11D^Pf{0~^Cu2B|+Vv37p{p0wrUD@9q{+`p-R<4=~b|L5-EGFdLN6#=df%0i;E{`{}SMo%$OyVajl zt6I;PHTzfVUqD##j&bu`C6i9d{k{KTCC+@)4&3Jn`1tCng_}Qcpr?QK{ph}*pDx7r z-m^FVFFY-r_@A3u^Js59&n+E(%N<(LIvLge&L}dCroee|-G@!GDO$})M{CcY{@2?&<_k`^^Mrn82`%*ER7>L>o z?^RrQFnNDJ?IE5)os`=Ql(RtnK;8crbKSgXu+cUd?l@NI>~QxJ+`rc^O7K0KO^Y-Q z6qy85t@&%p_mzueRbsuQY*@LNIVdh?x&Ht&^?jOmw5DYm5>}s0$M@*glpE>4=E+YH zKygT+`oQga&Cwf*=KM52I=YDaMv0gqf#T9>ms^D0ruf+Ts ziO-00b7^$7mo!7tTG^WCJZuW0AA=f;x~x9wfMwI0{I4{h`C|}u+zNP-fB527IZz5A9U9xv4tA7j-v0~7dSNZ=e0t06YfwNXT zN$Y{*NL`XrS*&|TCRsS=hRlV8%!J7~WcJQH#o|obQ)Z)k-Is3sMzHx%futeAEU+aj zE|#skymIjr_7odB@#>Yu;Tg-wtJV#LOt@i*8*QkfWcopMrh+S`a`O9iA&%F=o$CVd zF(^GbakXrES0JKVi$?{mX>EiLUFR|K$LI|m?l2H7Rc}#%ga~odPc`Xle!)~I!kQqM zBTzl*hgsA8h)56S+UiSmQG!RJMM+tS15R8?W)ECkmsdImgKGPePZhI0P%5@t?vn3s z878AynIe zR_|G9*rVkJw0hDN%|%X-B)%r1rcM4Bf;3JmvfxTGoBpeUG{%!Ese0XAe*l@KK*D1Y zljM{LEJ|Zi5T(;f`?>~((Xw1(Ux$XGsLcG}RFab>u_7aLwk=XIjFZcNgWQ6IxP{5j z4qSjjjG}*WCQ_c4Bm_dl30g~}UMf#dgJblJpwAVT>~{IKIIs#u$m?tnYHGghxQ^BK zT=yx;jZZeN`vl3;0b1+pKC!SoYi0TSo8DaUHh8rIWy)=L{isw<&a63GhNkGw8LN#$ zokQSK?Li3Gf$~8JPOjgUO6-(2;`zg4CXE*6nF7TIF|=8ly* zci0S#qOu9`=~SsW*6ziD=5Y;8J`F7ZO$Glp0(cGX>`(rD++S)Oabuc~3;1o*x2&v^o{Co&_%vYe`0N@_sY81vo-%Qe)^DFXYb zD?Oy2PxEtwt%`bUIkqZFcPv*wY42(YD2VWDnzc|V*sMr$951(^eYULq#xC6HCQ0my zkh6^SRR+u}U=Bb~6$lq?2!}~yFfu1kSAI+cBuwlbzf1Kh2R3*xktE=n zuJ4YL_+*wSv$3J)Fl%g0la}Ji@q} zh&dJXDD_xVNKJ#O3hbJQ+l1=s%U*}{_0j~GN|A7e-8Av9lyFJ;AdsmlLTmk!*4!qV z5*@OnWWu;3%>wbDI^TTIUQ7)>`G`wivEb6gfY++pY0x-23b6S_(^5i7D?~%IrdIfY zZNv{vzYL(X(t^#{vEb{H2l2JI!f?=}`)aRJN|1A9n&aPxsi<|fZR*?%>GJ?imymu} zLd3FgxhE!R#o!i=Bq7y1Jla)_h2}&)?}8&xe`0gFfK}9H9#V;?2z4V9rTZ_EsJXvc z{=QA4UXK9HU>Igdd>GT3p;5v7VP*j(V2>YUEndmoIXuYruq#$Hc_U+FEpSsGvap3C zYz3jN)Y`E#iInE78%#fGB47$m*ZNTo64}D%;1TefAgJ!u-hvB}W}8)U4|hQMM|gp= zyIqKb0}{|y*gK}9D*>fF{nAfsO+>vD<)dx+uWGeu6X&L7ZaxN3ma0aL5i6 zXu?YkOyS665C=a_p8P+ZxDghGG>Z0423mqI6-3xm8lio9N$Ulnsgq9DQ`%`684?n)wAwG8mIm0z8M|7oK-eo zD!vzi={!GA54}vZgeqWUo#Z0KlG?FcU5`ZgRJ21MSTB4FJXs8tCd5{5?HZsH&RH(W zM$FQ!;gy0;3Lu77V5B$KN`_HI8p%*<1dQ@bq6;0sS>4{kIvyUODa8n&i(`+P_GHlt z{XijcM^7S-p3xW--Oxo+NHSA^o{pGiD=M=zPPWk*bs*4g zTrel+S`Z@iltgKLz(D+@yoG+6;w$1~#;HPUG65Jl!sn3-QnIPI<#doM>lHf+64@1r zENAVCU7`5Fm2g{@0Uef;bm|$?B0p_2wv`pchlhf(#K#g5c9!XFRFiMeZp+tM5#Uy4 zJ~MRMq?Z(@OnQFuoA;F;PFtAfo(4QizzAmW4wplZEWF4-20ft48b@^AHiJskVZt~Y zXy`sx$E9VZdtlHp8=hdi1@RCX9zrlNi2y!wOwA*%ZgzqDLX1Ea9$;wj#~;y1%%c`G z&v=T3G4va)5jPf^ zqVW|tU->AKbnVCVXxY}Y{C#RdpE_|C1ZHzZ=;_hwK>9=g(7i1gU8@(?`q+Xr0^7sM zk}Q6U)InTHaoC0%bIp?ZM!X$-GtcE`XB?aJNGw8`UW3^@p5S%u*UQvNv&tFyCQoaL z=PcXeXU|F^8=<>IA~TF|EE8B5aHky4#e!HvxZ`+p9{Z}0=z=+TmjervcMK_N4o#v6JA}tAB=@2OC4^<@#ICsY&#EuUx|D(6 zEZJnVX|4#*S|Rl)yufYPWBi>GjFGNH4yxys*VHVVYj`Mi6ZRs*PKAZy1<31Zh4&a~ zS-sgAuK8Ww292kIhP6Xio|Ye+i^FJ}8rhrx5zdyFO)g72VylDsOKgag?av=E zZ=fy3Nzf}X&z)48IyhGxIiCyJe-|Lwl4xiI#~ECcWdXg^SXS{VCG(L!lU{Pe<2%ta$3}5raGuj?-z?)D%`Y9E<*g76X4*%ogcWj#qwnLo8G$oOrF2#d9COvYSH}`jd}{V>MRhF4hh5pEqUg_5$B8zG?Rh~Xpp^j zlv2qf?V@l=2$||ag6hU`Y)!5kM;g3$Uf6lc6HUlBh`ea(<4^$opD`5;vGC~WIpAHvGV_P+6%#ib=c^| z{yh2?n>)J>i(f8BP+NIX;7L%Tw$1G9Q0fj%QwO(IcTP9hI+mGvBgX$WfXaB`D;&Y^ zHVE6Byk%Z662V&yG0ddbl@8fwqA^>5n~BB?D+jPRQw}QVc<#ahaO;g6PBT0AeM12LImE;cwT5&v69%)`J(&`*cAD zxV--MdgxDI&Rqxnf16O15p13?M*#d>DZYMnx2xt&E--gVjqNV3ZJxVK-o#tv;Y|Kr zvC(efAnzr;AJ%5Y_@V50n8ac$lY}J!I~|ZxI^L0^qkwXfjq92ZQlvHtOoYSVzQyFM z^cE&o%@KCL{WwAsP2fW~$f0EiGa4J}rYIaQnDyeUx9SVGGXObL!CUwB{bZ_o^5zr8 zl~RVy{m#qg3)}N(p!%ivYS^K#`7GMm2!SaWUh^l<{Ll$F>qmL4H+dyVC!!y3PQ7un z$k-M$!sQ#`bn^YYHM4k%q#KceG?mEH7vnP*N#}BzgDz@*N5UBw(U1X6ue$FMAVFlj z&ay!+SZ{LuTzA>7KryZB&NFuE4q(f&MJ_j6iSd(R@P4 z9E(Zbsb<>_08`8W2R2oZ&?6oS1kfMGL@KgsV<7{YA&jS5JL5kYz;y-&(7KRi)NL$V zCy;fpclT!&=$;nb4dAP}2J&~$D57=(KCbWLb{YkgViX?F}dlbcI5>%JNa}Zvx@Aqf1AJL zVM`1A%T_p42GyxJHi%JDtZJvr4%~&EzGFD@Kk38Y2W8RksQ`?c7_-kBndJK`$}wA? zhJwm^v1H%gM-W`HcZM zQ1^#DGg;~o$6}wqt&W(NoLq&E@XRh%zsW9Wt4i&HD`O&+HZ(;%tm#NC-7c0gIDf30U8Tlui5P% zN~N$kD{_N7AKPMel1%MqximW`MKuaATGr6{YkhN4j`xhxoUh416$d$zg6JE1*~;B8 z(_Xk4qxR&MJx3HXN${|@SE0ZRPlT&F@LcR?GdywoCBuUSOnU*(LWW15d+VM)4uH9n zY@iL4E1(iz6>-2dXb(`Kox^o+^7#wIAfm%~!%M|qWt&EHcvXS6ZY7VlMV2V^vn4M(@iOrV08xj3Y!Y`1gqwe2C#_$5%=+V6e`lK z7`9o}x3=+Y8mBlyX#@OewjDvI9yzkMs!1`LY);+8L9{~2+A56!rfo8DlRooK4|rV$NZlo&3i4e#sT#ksS2glwj@h&^gXWEw-J;MgUo zBvAdX@p@yBi&P6?UDq$JZ6PN8xvF%^&gJUw#Y+N;f{0p-ScGuE6uVgU;GP6QaLz?j zmy{k?zanN9Zg}LPEINa9*UDV$d*KvOxT{-_dOWK~trF9KYKLgjIz&_rNDk3za)`7X zz;oFlTK9lSlpG>3!{*AmFSrKPdjd*F<~5e7MUih8d#D737t4K&Oq8l_Q+UE{@yl5h zY9r1Ir);`PY%A@>1~9+7Lt2^*i4C_mux;N%T4{$gX@|6&hQz)@ZST)RTK9m!Sjs-$ zY97v81)&9XqQt_MWH%D42tMgbnF?M5FHNOV8}CNj^}0_Wtnp0X1uR@`ybz>bgSVQk zChQn#0r@u_X>7rB=FAl<7$b1ugR0;GZ~`Pm{_PTZ0T1fX4$VDgVwa(|q`_%YGtxtg zo3{1J)BfpsT#^q~S)0$?MB0Q#)@rQ-jG*(Tt*19Z3(W;<=o`TxZA0$Smop}q ziCD*}n!WJ2Pa@h3+`B2Nzz41d>v3B>5N)+3e+XfaJgCm{s(J(`JKZ$AeLbQ^(}$w0 z45aMGrd^L*ydTB4HwobYv%IP76@7f8C3+Eq3BnbT8RUUs*ZQ0ciYw?G z%0%-nh>f5`^`!7kgWy&1|4lYZxJ?nD>W6htit0RtMtb#mJQv?ow-@|wu4S7uN>x4G z&F4cu^EN31)!Nvs;2Eojnn0GC!<=gt2%Q&kseA+a0wTUWTwb;b?k8 z1QhG2H@V0e7dzybzihH}FIf{VH6~7bJyU2^G;Yb`R9NZ%EkTv$B9%#G>hT=nno(Ws zE6&HwTGRnrC;zJCI)vS+h~ij2_M%tO7AbIn;$HQ_?bNo#9M4O8OC0bIP>kc|0#ygm z!LTYoB9eynFdchYX}XA`@2kun44@t#)w5>)^Iq#_Ya4fI+q+uqBl;epx#ujcd zB@JoUI&%nfQ?kFL9=N_JSPbFimYfbyR9 zn0|PK`7;VqrkEALM9c~;why^sAvU9 z9O6eiSn&#ifKJMeuus~Mvyn1!Km!J zFc2*EdU%zkSG}JGY27OVacv(u*@Ik7!0U1vB)6B>--dW;knOyI#4UP2X}B^DLeNtn z5vs`(nXyGIS8i(o$tbu}UPTRj;n_Ujkw$KN+^mFYcF%DB}++mtTFc?_y zROGQLdsWwBP8QQ^PB!;vmRZ$%W+p63yBew$OP_iedG(jXGK(F#I0U&{1T4fWj_|B~2A>(48EV>KSGCTb7y=zRB zDM;$4*9clkzxN0hBp0|7c=vUhqv>_6q9FS@h@d%e{&v8CBJ>JN8&(A>;+ixXDO9DL z$@?O7<`8GW^inIwtuKO3`Dis;F+Zh(WdV;w-sMDGnm-IVCAkxz?>XN2QZ*8fES5PP4{7Oe~tvGRW#w5v4XMp9Z zfJKT}u*gJsv9Pq(dV+=3>2F^m~x~hfgDsKjRSz$tF4rX{Ie^S3O1Ud5qB4gy|vq^ONNh8M#x-R;LBo@qi zGEjmHKhRU&i@ zS>67KC;0?PgF;q@4r#K>HJXCxI)7X>3N85#IUic;?x!Q3n3$}Gy<-G!PU5Hb(PLT4sNi&lLaB0|g!gcxO{ zQ+9?H;t_hvhtB|m&wH{yg?;PM(b}hRwe72-gpyY}uoC?bHJiH8>zK-ePA1Nk5ETUy}fmeO9YuRc_KVx|myd#SQZ;dvK;WE-Yxn)dp<7}0& zpNs%-OHp<*y?fOu1>2w$m*k|KDL|9&Pm3I$vGs!Lx|(bs=Mbh`@8Xgk{DeN!D;y!$ zjkg$dL^nlglq5%*;~nC8SuYB)s4<0DO4%0O=!&O|!`$!51Ud}JUTf`1kD>^E%#COu z*-t21SMUJ4KMDzp7O{9li_&d*GsdVRNM+!SI|WGE2RDQV=ng-M=a{YI>4OKoD_e_sh-T*b<+; zVv|ue=`Y$deIIu*X^7`v_IU7xo$-q^v~Y~BcDNNLZNAf*wALMDf-=h_x;P!6w z)yRNGmU*T&!G=5%%D(wFEiN5B&QweciM?uh8zJZk0boyCcs{}VY%^vlRLHX^*byPt zFq=9h9JAp$dn1Bq3u)@4PIL;QX?UWk__wgvGvh67p#?HAEV2?>58lzpd(5~#%)uog zECIFLA??S!&7BxeCxT%#Vgi?F)J$MZdIx4ya-CUY?j60W>!$>lzrPVSIr zo7PkJ6@7|WpVdHJvaZLVlin;bPQdC|SdFluSwlHXPALZ{P6FBAzj40{!>TsyEltf7 z#QbvQ&Ik7Iy^YHF5_@q;azqE#D8rq^$7S0qYAGL*6;YnE>MPAHwBzvLc+Qh%0S+Tz z%2G%6q$MulNh?j;o^*fC#qE01Dl3gAt<$OBxF%29C0tG|`Lu3A(bBfYVs#0p%PGJIBtLQ~q zMQ=g99^_~%-*x8eA~->X4wOEr3G6v>cqqn^-8Nb)S#RWCh~szVudusVm@z*pMUo)ErKBh>VvfRsl?UuH!oilk1DOM`Sfj_r(-;a)7-?k->mh_ z$z;1)mO7ZD-sH&wx+WZ;Z=Vqzr$dP?**sbaY(^YHwW_2_PEG@roI&lVwC&d^i~9US zEqYI2*kNXR4m+$FRdM{N*J=tfQ&~qsm}u4{$&VEcma#X&YvSqOu#?x;dVr(t(M}wB zo}>X~Er^C(2#aBnfyf3IWdjdI^S963(m@%LLqjyeDo$xo6QCFhM&U44wVOgF2px{9 zANJBYYH~-a1}*`M*30I{e)-l;>wc)R@gi!GR`Ge?|7%Nxg2guuQy9n4a!4^t@?uCIfUH=jar(^f5sc>0^;R<}GolVC7))L!((<{Zr)rjj}NS9IE&_ zU4Xj=4vXsC4p0N zj}QmkdXR2psyp*&j)Mbyan_B=JyPlqQ>k)%ScA)tfO_x}tzIQILkIz9O`E*_*N7ufIi!t_ap90*SAVm>aP_78$GHYS)<(0ugD zVz;sD18i^sc#7%^h>{%wzSR1)D}FUkwd=B2{l_McZZ5XW)+!&LowTIE8v#4k)DuC@U4<2; zE@lTmffNe)bFjwmSuH!+jQInl+I>*=6Ab1R5TMYi5tdPGN+AgoG55NJOA4eN(z?bg z3nXI8WYKX$)u-JDxoB>@I^`K1Ru)JLF`xTLpK!KO4VcN!%2j^Voy+qMB{B!IBcyRAl+fLFsZlrB=0Y6a!J-Q+0PkTe=NYsiI1 zzT`nDB>)KvJkd*gM(!vbypm|goMQ7!kt|$E3^6wf4G3=g&;h>Uf!xoGB0KZGlEyfB zi>}xPrvRj;3!jd4Pa$yP@w=d+9>Z?fbQuSV@C%u~17nHT6`o+0trt;G481|@v`o!6 zB@^))j!UKnNONW!_FQ=Uhm<+X`0d4$U@Z&%%*CgM(Zl|g}tR88uKbC5@ z%A)XlxILHgx@IBmGu0aOll>z;=!hdL{JlD2Nn|@{DQI+?jV26UzwXwF2b_+=i~M>P zolJ7i)B2^%L!DOj8T~+`>;WAhvw81(ZatwlIicrIl)2hDpy=_w;J7rw@u+f#F6Cvq zdMsL$hJBQ6rBu5lIKPR64k2S&oS!t(xYuj7*8iNlI+OiFj(OQ85w?xtrzR{K~Jt^+b>Ok3r>b z<`!t)atke3y!l+wAj2%Fm&Hidp$oFr6G<2y!Zx91uno2qAq%oh?N|-vUqM_I*yH56 z<_n*ocOW7P5V%q%w2p#Fqg&AEB&v)q3Z%+`C%>c}T@1%gT7t3p-QVgAiTit{bl&sh zP!;S2cqkIeaBRNCF(%aWsCuvNU+Ad;EJ*V*lQKm_cuEq1qVfJNk}J&Nk6-`ar+8Se z`h}n1?TCSln(IlR=^QJ^tc=3BA}mOYI3pI4%q@?Hn5W@e@~jMB-TNLu@4cq?UBQO; zm(xXBd38_hOL&jHuxjN#0x~hg1@$|qep>3!kbvGfOu%is(F*$en8S#3T1nfPbnB_O zCE9`URhwWrdcvpnE|7k>O?#kERKKIO*<#VUt9-9b@T?)C#HinQSnPIg_V_9qA zEwSM`p9h9_OZbYKHDs>P(K<68Iiz$1`^lBoP?+j6;8|Ri0ben6$A=3fG8yoQ$B@hR z{=8PaJdM)>(h4Xy>L!+vF6mvQO?UOsXN-HRKkhtop=Kkt)oFOXN!x!O4h^ypssNtX zm5P0B6bVAHKwABpFd+w?W|=iuzn7xxSD$ zr2yJMaB13Z*IRXWT8g)UHzxG{55%tZena}GgA)Xw6uoN-?ORl^F2(6&&fvRBQRBPt zp%L%^UOEQ~>Ct?iZm)SF1uYfSXm?`{CVx9PbA4Skwc`jwZ7QnimMQqhHbbMTt*;Am zYFQ7x>XRQeKJeuULSfxBHD89uSss|Lv%9*k&h8km8SR93OJPB|&aSf?Y9qC(@Kv-o zn6)<`>b^n6-3&Lcuu|9(bFB~dQ~BN3iGKVT9FL41c$Ay)K=%P2p?y7sa(_%?OOHV( zo`!S)-Uhs>U{Di()k1weD}Ea%1j}ouvGz1(ZJmXvTIuAiZe3ml6_ttNs2O#6U%n9p zV}g@3lrvQCJ(mHPiHAmr5a1~@hx8Z^7TNr;)|j^Ylh?4T8xBim9sGkR@Y~TBcsamY z20!9Lsmr_$QTHaReq6zhFUshi>~&kMe^kBic2SF0HAz_=^X;OvWpH+RF!}L*ibzFF z56Xh^0wV#LOx4GE^Ws$B3R6>(?^gK}^V^N=Fh)hno<2!B2O8d6Yey1aJ(^x_w}uhm zl!L4=Ju`DwT6!|}hD|;=Qr=a6tq^VEUsxsgOaOrltH91bxLVf@N8rhA0KAu>&^0Pn z_6Jfal@~Q6`6X9IcVy(m9WFU94ooM(udQxh60HnC7$R6Vg*kv6P zP)8eKZsw2+d@V#c3()zN9tlRw92cJCKyP31RYg9wCKeozpOtDiNC$0ie_Tlpg}(Lh&0GY zMzg)lq@0&w{vd?|BiJELuiv1tyu<(|Xr2ANTDwWM5hFi`fF_%VXg0DY^a3t8u?)@Y zinU0Ikg&|!(GB<}3WCZv0r@;AENdFUcX3LF526;j5Bi+a$=YVdta9J6yQ5wuZ&HzQ z>8G{LmdilO0Vuc1hHY=*MWu0d1^>fe7}Wu*LBaIQ=M?S#Ia$OQM=BvCt=fFzGu_KF z4dUN=)eJ}zha$s+j9H=Ag=)7bqROp(0MAmIkBJaqqrk9k@fP_Zm|XFel<`)vvESm) zf!1#Xg8zp*;3JytqVHvN8y6a)}=j0~K>+K%xSc z)B*JDPgY#4ipYST|0p<9=8hMFun zG$*Xw?Y{RIn2$@LyD_}Q2jvHYYOwN%Q8B|f76vQx6;@_}vlOUp`4Lo+%xzyJ-B#=) zg%;9GMD-UG4q(88V^}mm2nOV>)3sEFB5Q1fk;ACe7jvs7t#)x1oA{XBjCHnt%)-sd zFg1;w4QKRb$GYkKyTcTC(Jxl-aoX~JUKfUtAn*|jYKpV-V@*14$8}x@g51@!8aYog z0qf4SXrkKcuW!^_ zwh)12Rfkf!YfW90`z*Y+EHU;foT>vcS@KKEzT!6m)mnXSO?n>SPU^!DB&TcuTq-v! z+ki{a1*1$|$d;N4A}=tg4YPc-PM`cjwm_U+lJ@lspa^jA}ue5DowGW6JoLy<&X*(^2T5p^eS}o6J5{(5EQ!aB|0} z91y2(%NFT)mf@~&aXq|LB^q5MY?HfaiVA6HNzE8j2uuokE~70hp{_}fNZ2+B729P6 zMCD!?uoQ^~Tt+2wcFXaL4)l~cD-Acw;;S4rdydqBg98fVcqzcVqdoYUGRCI&YiQG^ zT2n7Y^x_jG)QiJP;0U;lP3w~GFrt?t^Lck75G_M|I#kuPF} zL?2gk!q&s0(;Pw2yj{E+O@4n=4v~n(9P>GeL=+(r4OU~Qw)~eCUCenCWsG`#jx^Au zAcHqHabV8Qh@P}yE}ksq#3ca^2ew4FcCmgSszuBMaS_7`dI%$;vyjLy)ijsFR)J`G z3o*UWmV~b|pG%uhhw09GxR|wQHu0n3+%a90pe=?Zqn!dYfJpqPQm6(7E>-EujwC10 zs5Js;?uvoeK#N6BTR)vo#CWt;z=b$r7=_Je?A0^WPd&j5WI+OVa^( z^~T%)*hgnArV*m5=oj)3aiN|zlWRJafNK7XlMdaTIFB0ge`LrmU4p*!m4cbhCx{9>{LFSppAmC z_Gb$~o@G&>RVvMVTB8tY^}QQ-jdUc2M~vTk7-o%Lk)Xvy2oQ&+c)KxlziTUr^{*63%8fo-)5a|o zN&=xJ7R8q12Dy!Lr4@)Lyowc_>Em(GdOHr~bZQ&}v$q^10X*CKuN{Y)l-84tYaT?G zZ0){&5N7Jrk?yypFckBJanc5VSoJg-yAnZ^Lk4zacCwN zB(ex-qz>meLnp`ux|mEdx!`)GbtZC!C!NTJ`R7K0T%$xTcWQDunx=(U$i-D5XuW^| z{>B29h!v|TVkGEoj!MLW-(Wk4VUFXMh|$VUUVq8NVi3BYFEbhwD@W#O|17fg-$<{g zve=f8uG7o1NI0nqSpzga=wHhRo!nE*lIbbx&`;AxFQ=Cac3Czeiqu$S-8ScIotX6U z65S)4FD;5`f^D=vSH@IK@@Ggd$Ed<*nB`|{_y1Yb%V#^YyfFrERM8Sv!%!_r7a7!L zK?VTM0{4W^lq{^;?2t^vg1^KtS*m>63aJ6xiym`(zy8nvA49^_JcbfGG1KK;a+9Z| z+y9Au*=82H1nn1zd0>)Wa1D-jVkm^AREm+3f?-Ldqp2xPto_%coes=R7chY(ypFO9 ziu?-(8!Dza9r_988Hw*AEI=UCLMB#Jso9mGp86elh9LUnV&hHcm$qvofceoMAJ0uDlB)qhYF zGuk|lwgo0VM@wtWSmi#t;Ib0c14bGR80|ti@)lBN80DTY`6wsE^S_OaqWbsmm3V^> zG~^BeR95d-&lhSO45zhAit3&-J*uJ4!flf~i&=r+ZUGoN!L?@r8Og)!bZ1uFaf5XX zAtu%;<~M7&GBcpf^gz2$!_zgOuB+9OH)$Zx*k~wyXyJJ!tR(kz_U=5zpSCUJ4Bg2T zO}kp$qxNJugj&4PUSk+oq&0T62C&MjeK)&IUK#TgakT-! zP>-E|W*c*c8ZsGH4K}ZDD`8){plhO+*+fq}8t1eRN-Fm0Adqp4gKT;{aSEx{3o_Nh z%44#oU|{f`1Qs>7q2Xw)g)?Ip^5&CWTcY)F!(-EvBLh^n; zI)M2b5WjPZ1>tq2;9jC4LXiYyYeII0N~6r&PDPfEjbq%BOOdvk;X zCEEhiy>v&dEip^b(o(D2+DagVU*;=;gjlj)iOM@0H|8m47)@!&ke=m}e)X^kiDaTg zV@gOhet@;9bL|aK!C)*C_!Cb{?)RQO?h{53e zkN^-$>y_>ryt)=yeWo5|AVLG8!I0*)fxYHt4a)IXhtMKETj^hp$s z0$nbE?d-DHoJT5fpOw;%7B(nhZnvQLXWAh+n6)~{tvXA~-deOeh*n$0F0>0ta3hr0 zFX2i&ilWj-F~jl~I#$jcmJ>=7w~1)9F$Ekkaavpixjq|HEC&K~YKT}&Po7qPhI9_y zbS_xSa;FuaF*EeimN_@CbsSib;xnDbW6K;K6mSWowC%6$14hi_4+BfTBr?GQwW28y zyJwX9Fvv_w<7XpM8tJE#G9w*xP?%Lfda4{nqk%b{9Xm`Oyv*p=wH!b3 zcXAQ@Of(@T3#*Z|frOmaoP-rb&xCcO-U`v_8$hbqsIPb$Dkwv^K|cWJh+S|PPYXD7 z)(p7$+u|AIGKDW@GT+NGZ+p%Z3W~>RCLK*ekA`aFb|bB0gLZ9Yovq!jvS?yK`K9ER zC3pSM3#=)p?VgBF^B=#63a|b`+wu4nE`=8OcUUg_YCaP~XiNvm8qwN(xwm#g3Tu=?>lguB+98m1cz zvR{4dBsZr;^?yYHTfO;|ANb7hNcC5#FcWiz<-v0Y8b^t+Qamh3^T7d+m={|4z%6=G zm9QA_6MV|!eO#X~?qm7{*hlqA(CU%&`{YpC;2O2VA;Q-sPd9c5o}eb%mlcd0HP5mI zm2f?d8W&qL04pvMI)8J@^O;540P(PYWp^^)rDShzy6tciy|K zc)0WZA-*@yF&DB++Hu+VwX5y@owMF?&mYv|(C>bKzPk4|KGpr5@mW46dwL{XNgbWg zQ}`OU@+td}zHiqha^D+i7c-!KlgJnSKJhgCTzybnClZ1xHYsDzg*NIjc)3v3ZLcc# zfM%7w3J*#lVt(_mCk?)`R3j18)xGJV5IbGL5Z&EAxx0Ok%R5ecHYZn)8p^Wg-rO#a z(;>}K4qlN2wfxNN8UH4WjH{Sm5odwSzVKx(EX5mN=Abe#s+alDiO_slTtFb`6tIro zz(0PBOYr+;#aBU~JfG);NH&b+;oj}9YS5HX6U1TP#iyQlP!vMa?(nBirM=Z(k+92( zxAC>PYnvH$PU#4mC5BS%YE>Trydpv6{%{&y@hl{7E&HcFDla(C}u%U6G`JK$kSMVE7AhF<+kVE ziv73Ta)7LRYc~r(DQ=XOb?AHd>6f0R{)>)3WJV8gWaAgrNnt>BwjOgy3s4sd`9duM z{>?AG^#mM~YtU#^ps%PN)=TT|>n2#_@7;*!wLOAwOn_*PKIp(9Jl=Q*di97@V`N$m zXk+pc|Li56l^aL#rSW3ySMLdWGn1aV(*tR4-rdt)fZ`aGARW@-FR9TmQTX<3KYg{~ z2*2fuIACY;^P7j;oDtN?3VOWX78^DT%gGbD!+YYJ0vW_Ad+kxBZ-Eo5pApOuq+taS zboproR=tXKsj@mtv=6#3QpvwTr2a8nI+Id>7zHV*1aLxbcm-`Sh*1u2U zFu>SL$z%VW z#L5p}R$SA;(=CcOJjKTIj4Pf(_dF=ieaCkf4;h5z1Ofw75XB(8kIeVjOA8oV(Lqe7 z7j$3|?PCd-4?!FM@}QUBHw}7yrK@-xgN-0&2O2p6JMN{;_-~4k_9%M~FVRv&T9Rpv6@nnoru1~4kkK08wRxq5&t#!d}t1XVu23@26qJp>dwH7L3XRoxIjTz(UR>a!JeSy zdg#9;CgUxzXM9tJ3@}b2*BFx&@b6+E`ScJCs-7?b>yrlW=%efynzDNPm>JA$D4qQ8 zy3tK9OmdkxWan&rCqKgYv%o{85sJ_*FE6C$sN{J7H>(%!+%L9mldyPxN!Ah zDa`fsWft#<2nls+P`YA=Dt9+;xmgE;whg}X$E+_7M1%V_Y7k4b(;%9l&*_4~ODNT6 zZ%SJAdTG_R;ZOX^ErK+uXzg`B4N^9|&t%zK+vIhnJQL9?4#!#d>WpTVPVGSx=`W6t z>uWedJIc4!RrTlcPKXrfLA9d%_$3in!Fr4735zL{*KT+xEn_cWqRa5EV1C%3-40j5 zRs7~$!?@q2Z)k29Vz0R3axp9?Dpb#f3U%M1B`($dy;3`*omQzOHA;7F%j(qK$9=#j z&=@aDx9w$-r9r-STA_3$P-;bE3GJg4d2EQJb~K6YF5agB%LtH`N9L`OPWsj(#>E2M zk+#qb>2|wvC%5Aj%4$$-yf~;NO%9vxA4#hKqsiBbLTSsh#oa;NGQ(?HE~ z6rTFLv6Fa#mN>pw$6k(L5mr)Oi57Eu<)zLx*L)H@Dl13R4YsNFt>g42mBhN%4vzz4 zB`IBhp&G4+q0BA;O?@1p#fObz+9kfC%mmcvrbRH&Lt6;p_g5`&t3B^crZjrK@J^Q zj_K+({kjI3w1J*>tAFkNy#cST3psRRcemXTJeZ}4KDx84x@qlC;nEFfN>kms>wfc| zaRQTZ;?mJ;QT=|{ous%(^KfP*mY5c#2@lxTm17l0qj`bMOTEgBxl`U%G~ye8KV7Uo z6RiO>_q-y5F*oF()$#}*l zqU_DmWyN*T_BGM;)#7G3e;mbjB8nkSUh7k+T+3R8LTHs8gwX+>C5F5N0(DgEYcNWo6}`Ymt_$Hc_oyvSKfUUNqUffJ=g` zoAQcv_Ox+8#zV_~6NW5qQAsy(VsHZLb)tPJoR+vn9+Doao)T@~2#sl9?quI=Ogz&L zYGWWHu^Qt`2I6?GTD|!KP1J)|G+nD%n3W5$gMYdeE=ZGlZ^X8==O z8Sy!g3hk{J7#-W(HZsH79?AnLbEn#f%EcbNhWIec*dX1%aLfJ$IcA6#Z8iP1ZRQxT zDze7u>VIg#*`^uG2~IH(34qIS?U=5%b#m6u^U$32*W89TLci5>?*+BkQT2JUyjPnO zsn~D?9f1iB$DY3L-}tevcnTJe@=^A#&xU_8f&iBPlgPaoA;pPWL^71^sHaraC(deH z@TJH8^!5`yZrrPCKWnUr_x?>kFb1CH~#fg7?h0K&UwI?*#JrVbU z4mlcjLB`zLh4GCL+Rpe!1nr{u2KK(iG=ik73Xp9o>04uD*QT=Ry3m_HYe5JdKumWPoTV16OL}l zcEh+{txJsShjfdgTles3(^)aQ`}$F-3k6C`pdng9_r8nGUpg~v{$B{~bCZdOku|5y zV4=Sg8=JnXUG~<=i5-TfZkD-uwdLm3%+1TEaWjD?@1#bzOY%KBBm5!c}LIU`P3I8F=BX>zOWwwNATYGy%?X27;jVlfn~|(&LF;ztzLR zn`)8#gq|o{c@Y*xJ+Q4XiZ>cf%kYv{XI^s6_wRzxf?ReIE;JhOFuQSSVaCMa?f^ z*6aru0-YvmPEY{HJ3FVb3YI66)6I=Pk_rKsPJ3uRJ%oXy8@q)w{yt$pRi|vo3trwC zOx&-}uP>-~)Z43{`?oaI^nW1HNDRpei(ldk%*|iB!PHb^o(3yum#@5IeicIdtPs0R za(_34`wPh-B$}Hcg$_{=gnp|p-a(JDGi3mxz+1gXQA)3ElWgDl80DtuKqa8irKEJQjo;^{D-jV#DwUC|YE&0L_M0#TwStGonV^uGCrB`K+5%}l$=+~OO9 zR^>KA9nSv>CW*_ylff%Mo3Jc7e9t9NGUAzHT-M%K@ubw*V6!lQZ&bBo+ z4QEE^#9kDqpIodJ1l5-N{5K2pX$WEetyIO04efC4p_O1n1Iwzs>mWn z)PC8hFsQK)Q(<`A6elO^3DR$KarlM>c2Fx#?xa@cngQdsY3BS@Zj$T0&NP$UO80P` zzt)@8)AC8>*S6R7NUlqd@2DsN=&z?FJ%?)obeqF*ubN8S5S*_#|AFj=JGcrE~nHhahni+>*L~KAZa#+5iyoQ($ zA6MsCwTAnG;}xhg|e;`&2&sUp9EgSlE<&EkLMvsgh zbU(VAE*w38Fl>4ZI$Wp$-DfL0WJs3Z>)jOa5-nHYb(XF{2v zl7vWqzTdgl-uv8pt0;`V#~1M)DQ+NfB6vmgITI0V3y`Bgz;0id;dyj!>(9N0TZk?=5nB)C%t^{^D;3R?7?F ze^KBQwgRK}?GPS!t1wpe=Td1c{zO2cm7@A{>H8~-z)ofbfH@@2-96!YK4OR3i zL8g=&L1aojoGay#Pw>q6^n-Tca1?}0+|6grkU=vp1Oibqg>?JgH_yn?nTAC2x3!wc zX!4sX4psJ|aC4!H=%uU~&zt@?V=8QGQj!FNHf-rruG#DHOZq^jX}PN&IN^$ zEs7!b`D`vxOBsB|**XWOap>@ge{p!abU+PjwWhAgU4)@o%`O=H8wi4n{AgPioAq0U z&9v=0HJ(;fbOb93%2{F7is}gkPTY{x2k8)zs)DhtiS-E__8^efoALr6ES55bLR|qI z&f&_4ho$G}j~nN5FV%yq=o7hd;Z~FCr_=iqWSz>ca}A)GG#B%eBjbLs^jKHn$x|cz zH#fZJFSG$4EMRT4`29}Va-%vB+kqs8ZvODYHVSac^A@oHoTYpC&iKz&+wrf`@T@V> zK#${|GRLVu8jLeO>}{=S0PpUq34`0zDyq;A$0k-KHKLwT{fJ7*T(VC%0koS73V4oL zw)sN_s4TwfcQr|RZ?7i31l4jgg2br_Lu#&iar5ESw#5S&akzzWD*$P`Z0=UDq58ID zg6`L9BT|q=^GJv^fy0>z)Rg(Y{2zL6FB51Y=;t#DTc!ZdwP;LaU>ftxr0gRTf~f|j zNu-@9L!am<*R?ioH@xBO@aUPau#O2yG~*$vUQZe_GaL4=F~N)`q0+SoE&^dQM&7yu zU~RPTwslg^O+Gs}+=8%ZH8N_+O;glfDk@{o9!>A-5ip8u!2U5xq?NU#5 z4c}!r@sS=V?#P*)(%o6BrRORt&O?+za%FqGnN6s?RTvDD!O3WayQ5hkqk)$;)wz(UNT&tfa)p}8D%67gnf#7c&d@0b+kn%<&ssLUo z&1YIE6_k_SrL_y}{qX_0={SSEToum}{Y>lQS@EsMtw+XcTJATQOgptcLM1x#dokR; zWIWk7h;maeRi6~o;T3VaOkX%mEI~Lml@=Df!n*rqIX%Uf!av8njxVw$f`C0VJ)@Rm zHSSS*kwZ0Ao^zXGZ$rGuj$F%4;?dieFvDvgfpLQv_>Q(J=61S+Hg*uVuGYt`J^kCr z8)cajTBNzgoQP}TE+)_<5v7FQ`N-@-nRp3Y%DmgsL22J=FXdM36J1*pU|rVP7;K$ z6;8&#xK9Gvw>HPR z*(2zDAycE}ncob8%BB zMOO5;hkuU;M|xUE8B4l}C%5}MVH)w|nMlJkH{;3Y`?Y#I(n1F}Yw(Ql%qyn+x1Cs! z`kZNeTQt0~eYh{r3UZGQvyvU(`-iJm-QlV_hIu;seEi%RWn_tm=Q<6N&3D^zrj?p8 z<+2c!cXDo(_L%B4=ul~}w#|M?a3oAH28JZLC5Ki}9(1!J`r5|-&olfYIR-x^M^?0E zO022C^Ze#QOZr4`&p&6t5r9$WLI=w5)6-VJKreBoOkD9Ip?MU>o@e|6%3$iJUeH4j z-}?x9K|&Dk5Py80;3s9Cfe5VWnIfm>6AL-BdYz_T(o7_*DTag@w*>h%kJA`nbQRPF z!uD8B=-jteQTK9^F{@r1jPe)rAZr}9sZFlu`-QvjN6HWx8Jsit_KcxLsb8%Za z@VH%^#+Z?X(dR)>&hI^tPcpke5#K%F>6s*QP8SiAA5h#^1Ki6<&y0n&eu3;14H}YP z48NGbgA0K=|Se zbs+dJ%;UN6l-;HARNu>Z_NMU|U0}fLLquG*N(C8JuUEFKq(hbvxB;`62k%0EPh5fA zM+Zq_A<=-FIZw$UoMw^Y4GxZSL&+g}fe$!t?U#*z$HxH-hGPSpz~RyEF(wnKiU<2`JaRZk4l&zsLEjEtQl4ccRWM z4>4BP3Qr&qv&eIBNe7plhud;cgnll~&s>_HVS0DxU<40b9szt!x(FeZsnDv=3@6OC znXCs}%pEW&ivu-JJV;TwB3THmC>x_&x)p8Lxw4-@` za!6>T+>*k8%e_{T#jtuq;4g@Yo4ce~(CDiEyqI|rqxMt;MMAp;Ne5W*+&<5rsDFDv zaiM0NKyUSwnh&&YXh;iteMY7jhM^Gc3&Y zGE0qC`!nDLMI}JHpd(I8K!Bgxp^`Q)oFM{3ojjwR_nxLiR6s*JkcM_J4^4t9NV@t5 z4eo`EGR2U#_6pWklMgMGlP(v!pFb)4csI&7NdVxE_RKCaW(7Yxmv&g=QKq_9S8Y$K zkbXFvP&>D2(U>k>F`ZD+r(X1F#?xhN;NShbKmF$a`x+`h%{4!*t(qK^r}7b7>ZR9m z)W?tz9*2c-U2DCpqv=+#Oy^s9s@|g2Qa+KIFaceXJV(yQg!1nkD|_{H>lHYF=HzhO7 zf)RtLjC*CGh4m&^6COcJ~k21-J+50{-LT)%>sj}2Z;lG9L@40wZ; zl`b&w`qREe(*s|&zi35qDL;-kEtKuZ;4!mPBG6SB?4s-~J$4LK@Q4XXcy9O44+*+=h`K8|Iy$=cko=2ed~Lj9XZ z*jr2k)jQwETXbcp(A*%j;0aW~5_C0x^^KpAqNQzBgUJ`?%dK4i2-RcUF%aNd{6x8D z<>Vu#RVd-C7YB8nf=57 zC~pdX@K2#i0tl=PArj>O>d4!$=lXN4R9}wU=nEr(oT}m zAQd$|_1I^~x07BrsXip4@gsEW8oNLl{KmsEbNvo_ul}xI-6Fb7z1a=0Wzx)9cTp)4 z+OReVrc4go-s97OH92nCm(ks#2o zyzYY5lsCEwK?vb#_}cg#|8>#zLySBWG~B{2r$joQ#UL)I09NxKvYrPUf~Qq*H#CW0NRp zE5a&LOqm(++T1IVvjkE^k9!UU3)hp${r`2*o`P}D*=@9@b_hjtk^d##SJXN#_jR7; zM~YzNQa*0YM<}I&Mx283 z8XmfngRw7(hp*uS*XL#aHC$uaQWJObslMN=PqKTj`7?)< z4N_d3=>iSo_Oqpvk>KWzQc9goAa34v_H+WDX)`+#f@lsd6(qM)!sehSeqrehnKrFu zI*Sddy}-k8?UFt?i9WxgXY1v9@~SO!%kpQ>y~5OoCN8MK%n4!(LSHJuLAvavd|i0y z@NznEl?=v#f|x4~xrEU|vxBW*hzq?qC+`~Nc+Nta#c<=b#p)x{^;HD5o1)Y!JzhdL z%P$=s2n-0-PG@zjg?ztIY@|6-O(?%^j*xf+@1J7cZGvDTqFj^ zkLCZH0q`Ktw1>biX_6Ve8>~_KpuvOLbmFKD9|GVWxi@L9#p13$VZ+7dXh|W^APY?g z!QZ90JJnVE4@-~5S(wF@ zt4+%URfF{sxL4pJu?50SIgPppPNX(~jfI3OWk(|lSHMN>XjOtG3;~mutf!nG3-4nAa7A-lcoP;ISVte3pz5-qRCI19RYj z*mCDcLpJO+0ix}!zs+oggG=zBM0`bjr_E`Jd?|0MnX%D-ZZ|Vhhx{+LKq1i^eW(m2eXqZkRZPk8J4KiIbYg#BqSePk-`ucaxVCB=*+KOkNT; zc%v?08K^vY%e~3N241RuKeJUQYrH9AhYm0C(FMiXD){G!#jtdT5e$^KF9>^x8eI_wHjIVsvmSs2Ny&0^&nyWAe z4e2;pD?$(KSAA6Yv#uhukmt8(kMW&01h-(EsBIH24A!9Xx-bIak-lPQ>30-;MrgeI zY{1hPlo=2!f+e8bll*4VsDOO7{vJIWyyM3Egg`*?gt&xVb$Rq`L~v@B%U<2?I7{d0 z=vQa}?7P?pX&s=h9o(8##B1GOcK{tD7Wq(hn$k4Z%6UWEX0 zB;%i9O-QMgsceY|;M##?C{GGJc&EonNGxEX|E3aWXQTv(yR{;u)v2DMGFtQnh=M8& zE8t6#CS-mKAIRG;WipG745L6xqJu|vY#2fY#48uUdo^q5z0hN8SB(}m7~NMW`w!4VK;dc2t4~x7`fg#^7F5M zosx@syWu|j!I{)9B-O7TUH{A@|9<^5AGvkrnJ?(*I%Iwk!t;xF-!2_c3rL}*ZngB4 z1Rgi4C#==uorD~??I_8p*>XsUHG^hL^`?7}C(!^x8`Ba`i=CW2%oE^*8m-!;7(YTJ z(U!6{p@{A&9C_QWYW7^c{#jkW2sbC?U0%yBdW?FM&+fJ6MKdobrIv_}`lcT1UweOK zzh@j^kvm`Z+xU^@oVwgK(-6(D5}fw440`h0!YxiDOv=Dl!Ri$R5W9*|8o(ctPo_Ok zu>j?7#FFG3)Wy~IB8e944be4n`15V;->g3870SD1l+qTfDp*x0i?M5Cph&bWxx&=G zY_L~iztmjWZHh86)U@iNlo-v3=%8Ix=_ky1GJ!ysoUiJEG#YPM64zU%LO#aLW15CR2wCNkYfFymx=3EAyTYBgWMZRv)sk(?5-U*!@ z<_J7ye32rOZet5(e1h40pY?woK6$Q(&>bg7=)N98J3NZ|!6S;0cfh3c4=>WiT*j$j z6${*^je9Vk(7T`ENJ|kV$g|B9fp{rM)Hjl|ueSNaG^mBx!a<|^aTOP>Uxn|?EO?%* zji@KiqiQD2v|TnGge^d`Gfn@RgNOlWehC^_p2-K9d-DADZYra~Jp-OyZ%~ zoOMPorRd!=#t)cW=1qEmw1L`!Qn5(nTLH$;G>K-N z(+*I`P$;WkyO||{9#XxHHnaq2Jbzj2aNw$Aj`+sFB!Q;w@g6jzbyS<9^abCYrXv9> za?&~)%m9$>I+}4axkm#?u~Uv$E0f>2ln{{cedPB@(`%S~nKGYHz({KgHo$d!FB-Bb)YkWvho@0gB#HuzToeFN3iYU}l|-xIz0K%5XK+W+ zJjGtj{LYWFxN^zF(0u9e5fH()5g7y?Sjpm{0vPp8?(7j4vSjb5Fs8J~LAwR#92k4g zp|my6q{m#{UZ@lxPrdEI!?aw$t-ti^v~8Z$WZqUxm6DK#&@V!qK+0QkpDKHCD&Iqx zs=O^kh3$A(L&@}^>f2V|5%6i<;?i1ihzI09lLUC=O}DOT29*kAn5xgmSOv^l;rs$x zS6j4xZG2o=59KqvoL|QwaOxDgQf+Lq^PW*)`$s87#u;~C!)nU}G{aZ#%7-`-7y?!# zhY9s^W+P=AN@5$Uew@8S}}=7*&YumrjB1z&#QvVu=(vAKpFU zlm|p#@=HtP2o4@*wbCkW0z7Dpm*cGn}okEA!pl+aTE6R0BLa(riv##LBe+91928CNt)E;{S;ooXa`L~m`tv-6K z4f~xK&TgBZk&sDtsZv*#kD^Q9D>UWJXMXVp=%_%Av2=nvas^gup|o-~krl1*;^?la z*5>%Hx#L5~L&m5Ut0Ol6;FOldW#S;js~7T_hqXTE)DI`{sRoMG8g&m)nK}Qd%#zQZ zxq?1yThjMVf_9>X<3lY->W&`|4v};s_F;1mUr~G0uZM@)aD2a>)y*$<&pqZldRi-< zZho!1`DNdHG`~h;_aVXnkj-k;p1emtVB357Y>wrI+=_Pl-mlwyK9oKmO`peyj3dEV zJ)T51Ej)yY2FU37x~X5RoiTu#kH;h`*OWg3>L zS-G#lB<1oKOJU)JZ4*sST;VC*Os#3@yt8f9rsZDE2~P;3DDQ}%qbY{QWw5~}BHn(u zWLWUwoyC+ro}&73N9^DDN`l*@2a>%8Ah#lc(`8Ph2MiE(f7}mTQGH4|{w+Px1DYfy zGbFEg9tB%f=`~*GsKi$%sW2iTVFh(GgsF>aEDu4w(oi&{CB=k1@?&Yllq)kHjn_M3 ztBrB0S=K$qY3%Unqg|yW`3(-clHW0Hb5|lyBL>T!_ZT)OBw(pv`w%2yo>nQ3c13kU z6yOoM1c+E`I*!V1xGqgWYMeZG2vi&T1iD8zsGd^o<8b=Xnjlo0cCGUiG8hlWk8*Ae z;3~UjE;gtikIcsefqf7RT!zv2sqZblzHcM(Q^hn-*7uYX9qu!g3P;A1GUu5CK z`~xpp4{`!{s-*CUzH+r2-tn;m>bQW8{rOE|kL)JuJ@dr26vzg5#?+RCC1DID_f+Un zEDx+E%=>M8g4H`z2Czl`7hy^4$5QFgd9bk%OSUnAaaV@paf1KDrbk|48r{EJyck?` zFWO-}FD~kN6HWHsbgM8W@e@KfIU=0YB(sG@2Nc9m^%v*k9^;omrg1EBM=7`b^CACyIRBJzgdOrviBb@& zpTfe;OHDGF<~yEd>|gz~o@1l> z`sb9jz@seR*pv8nko z?h0@hsgC!yb#=VSi>)#9A<+bpFlIh@t6vEmubSpokt6s-x|$p|KZp?+X5l0ar78Y31CeUPYW?g6;L(pw z96~?@mePXEc(5{NhZQc!?=F8IRm&qkR4t*tAF7uBrBqAT5{?S`*xD$p5(cNzE6-Z5 zSCVf{;`7k@szdH1Yb= zZudDc>-=R|JYDAoZcga{%^&}k{2L0>JRAQ8DgG>=`mgWb7$^V6xU<$2a@g?ju6CnQ z+Msxv{*8IY7nZI4Eo)>S-;B(XuDGU8J0oRk9|;w~&UJtc&o25M2T&GrDQEY%n>l`E zIDf(+gE~>&@Mh^vasbHM$Bwm9DUSv^fm|z#Xb94W;wA>%j!;AycPJwO>hO$f))c6j zpY^+o4nlN*z5@5df2zdJK!+(0VcRe zq~P1?EI@Pwx?1t>8u1ggp`Q}VP5=A0-qQq$4cNLvM zK+w}=;n?A76dlp&aY&=NRHT8_r@eURlsTyhQQ$)9Q2ZfAHUfEF(Gl79OpQ`pXji9* zn_!7fLkHN!s(a#FT{JoJMCSDTx_ENxzN8hWo~TP&IACMnKZvnAYoa+js-Dz5%buZJ zhjNIgB6%7{lUqt=AYrhpQZ01p{Mv=9%$TwjVQFC$^St_F8QnYrK`cxi#Tn`ez(B_) zmgXSb3kB3S*cEI;To+g9@87`fI1S#n+ilfZSUlSE4@hE{a9qE_9AsZncXK;iT;H5KdO+wO0 zxO+6J8sL>n(-5sO^9Z6;zcLa&*#r%S^@RK&{F?E|=Nvw-c}!(Erb542@u`S%cHk!S z1JMarpaE6su0Hw}W=M7e zWVe7rvUauKHlN2yhYUk`&xtFF$v>1-Ozodrm?VqHSJk!6B=3cIB3?7hfrgaubcK8A- zx4gAzCQrJsgttidwGh0XTA#qAIM;}Ol+vxGCzz2r&S+SWUYaX;vZv!i$P0dXW;FDI z>qYe#5jsdl5OOoUz_VUHByWs~g~WUsl3L`C-KoP)24MxzAhmA@f~>Jw`CVmMfP0|C zQ>l(a#FVMLim&(NbeA>L)H7K#UBDHHi&!?Bz0HqQ|EOq-oAD@f^Da&E!c#Pln$t_l z$<6x(Z}XoHt!$?>j(e0W!p-4bAU5>@$=#?t#aQWkL;E>_bgI4|MS^V7`Q(jdG2ate zMNlx^GM$xswSRUHWnu^tUjr?2(2L@D;*&C^2BUEe8tpabRSBJ(x6vVbJ|P;)k^G#` zB@s4xI$lQc7jwXvuTSf%*s`m|hKTWwc}Qd4wbY-BfRGFa zYl}5lz>urRcd@-?l73o(hX(C>&#gB;D;6$@(9iW6Za%X|NQ`A>yvJ#VKuk32+ZSs6jD;l8Yuk7Ye9d+|pcJo(mm_JL93u?4m_&iddT5#^3tE%I38ILVT_$T(0%*lD z%X`_wk``&(6(FD>Dl-5Pe$}KHLhiWy$S4=EnX4-WdqjDcz;J2^GGhN6SrVESc+y&B`{k_H);|vp`KKR%4-9q5D^(>izWFHxN@rWD)^BaUzJ%1O1>2`^r$>jaLxY}mf zf)74$+ZqOy2l;)-7QAy~wjgXt*ghS!#zGTSlAsunev*X2Cl;JA*z(JNhJ-<>*gt>d z2)Hd7oOSh@GfsLr6(Sg=8-ZpP{X+5sGSC#2hb(v*xkS#a^mp2tQBT# zq&94+{KL>vkdjAaQz9UhwMZ{=T_MMSw&%QhNjb{dmU#ii-M3-HEUjp5eQ<81=}!5C z-Cj;Vk}{FL_sM?x9#CG1dVNnP|qmS$#q6gmFA*-a3Txk##359L?W0iHc2jE??z?$RmIZ7s0b zK#R)n_YwsI8KV*4J5S7&m(f13CyFdV`FYJ$HvLi^Zr|u zWS9^)BRQD`#Q?;SJ8c1=ozzg8(LH$&g~R`X$~f)NhH_K_S zTZN(O6SnvBpsdUk+j>Q~G*eO3frK|!b6{1B$#470HHPJOPWqKmndZskp{fsYNlv5U-l+SIcU73Ov$}7^RvamyNR^iXg706G6XVC>Ll7&Nfe1;>mWKz zjU`GWEd5%ORuFqSAA>);{U%)}pUz-%WHe(c53{MPDWK5W+L}*Rky{nZk-4V#mT?)A zjSX&cy;9hU*KA>eqU0HbzJAZVDn-E$#7;N)xTH5&eQ2L0YanfS%jNUbBkX4Dl2t-H5}6`xeIGO6NWTO8EN4cxjK;gzSzJikD7qB_0IxDkYvyGJ=WGR; zA80o;7@xxzX>+jnyv%QOQ*AR%Dubq0*+aRs=-VDC*F zgJl0$%p(o~d8{};M*U-50+DUB1(`IOSLVICUr5vsY#)Ayhm9Yq_MiqNJ8jl91@oau z9e}8?PqHMF0dG9m5!Ee3qseb#2Q z;);LmbWy;Eo2=BPU)++ai^vxj-&JBS$X!(b*Xzdhl($5c8ehZ96wh55GgO*p8u^tZ z0(thJZG1&NcU8ZAnXPh7YTd{_9Q8Ds=}8{FXikeY{}R9jN7C)^gI+BKzEIlofG$Km z@ePcc;_P%L)P^1l1^@gJA>VE6u)}%BUDW)? z5INBT-m|8{FRJ{4^ov+-L7CW>4?Uz3o_NUP0tbCL;FEkM8k=Jj;CaCLL^r!}g2j%mJ%nUE8j$Ne0e&R8h=4`^K)SD#heOfmh3 z-yanvWQRcAW0O4&%IfIN3wIe6Add{K|yw(Djh@M_b^=;oM@@h&-pW>1LSPrm?Kh>LbM_>b+)uu2V zWi&>LfNyFX8_-3!u^!dq$?HblQ8BZcU54Bf2e^?HnqXEHhHgC5`75RiolqidF3zV^ zMv`rWLnPZu$u>zgoUpHD@sZ@h?aFn@IH+>q3RzIgvdVZ<6b_>0YQ5y~(`ro(qHA~= zK{H)eS#Wx#EI6mjZ`zvTNJCMd#Qlo$}6Q7T#|+|_OARWtz%YT zLYZ0KSb}z_ekUh0tyy&_fDS&Q&f06ILvxSm$QpvujVQ|uCB(WtG@p69|Mj|ohQMwP zzVWga?71P*IniOKAxM#$yP~Fabg%u;5ZGj%pfV{g%yc6$qr$aDy z8bE>4Gkh~Ce+o>43yfA(*;|D36_bU(G-ap~8x$^Rck-4Ws#l$Qh03LPDddq=sfu3+ z1DqWf%pbmB{>LZ2(9^8KCFBc}TZdR~#ZNEvqCjOV640C+GV+-W`#ux9Oo=$gj+9aJ zL^?c+=SQ)yS;q;YZ`VB+ah4r`j;b1kJguX&OzTMG`6y5n1^y=4cMv~IZJ?tNR2L&s zS;j6##L|~zd=s1C;@}+Plg^2<(Q-2|A}4j2#H=DOT}_8r!*fucsBOh-PI3CJ~lY>345f^f~=nIK$SFQNpZK>0J4QTVXVK5f2lWfbnRQwn0IL5fLPbh z)6xXm^RDGjgMUzVq@xnLz@R;*kr6m}s1VOC3rb!&mO~h5o(~po6c09z^{9KI5Brhy z>_fWDCrOaiuSy$4RtnY^4UZPdZ>w7M@GMeS)hMR(L@qBe*l)Pyu)O))=$}{J$JCRI zpsiM}X3rViliXeOaCaf|ROPC%uP>2yI&8lCdbg@bBMLueGin_}KlZuk_R6%ltGW0zB9oH=byX%fofHYV+KQE-+LHaWudN~^| zO^63Wm&fcZdUlTIpbZ>;88{L4>50GGkz`oRr%Mlf?-4rrR6iI*+Xv`^$-N}nU5e*& zy9kwoLDgWk3kHSnTjDWFV$tCv?y&k5%{w?Y*i4d|-XBfNT?Ikqrs?{^l9gTyszU{* zQNAH8Eg(+i8}#K;{kaT5XR|_7yb7hp@8)J?BB5Zt$b?^%wf6OX#CQrUp zsc(A^Rd4P%dvwm=rJ6oc2wpVYi?b`?hepqHlmGYtO|qz&6M6l-*)|G#rj7F=WhS?R zA*;fSes0)mNOo4|SojVECt_{`Rmw(w!paV{E%Ys1*41s=gr{8Hc`2+zgls^NU1t8L{&9)Et6w~S3?5pv@lBimZ`D=4g#!80D3Yu~=Rxpyk!$>}wtxSxB%XJ<&#Ypyi?J=3pgBtP4yj0a4 zd|HiDX$>KSoJ!>i>5rKwXZWsIY~3;lK=(Jw zqqrS{KE(r2KPVAg7bsNpt{~G+Ss-{`LY7N&RDB$x zE7G~}@LT7y0F%6$T}5KNn%1oLqRjP3H=7yt{A7+J%APJJ-x`%7;EsIDJO&HENGh0; zqPGh5Sc7Hgb?6ze2vSMJu*^;Qs{o%(?EtK-8JBKTWw(?|9D2PTjhDhbj1qx)*$UeB z5EW1VCfCtTkNq-SFV})x8_a0$srCdK^89Y*DL-PQ(!+|X81Ou_x6@gc(QDJbL`cUk zg^Xt=^pbq4wa$OnXtk@xVTb^NmYqRXeOMsLbtEqv&qY$B)%%g&3lwp06yt&vH#An= zr$%O^*~eLxlQh%gen%Z3GJHIhy*CR}R&FZg0UOR`9MPB>t@`5x#ZlwUE$QgDVLq7+ z)e+qogs^(Yj+7~cr*WdL^tGdY*BCSaqKuO=d-HRm$qJewkM^?X#D`qjZJc!cF$n*I z5jlAw9R^NgI@J2H6K|l@)8u~&;QZXQTZ~&8K{?E{uuX)}d!(IHGI=zoc3nmeO!AJ< zPrN<(Qt{kKis{C0H8-Mc!|JUee7x>8ciUiphyKC|Ke#LyLy)py-mlnx&${m=Y?>CX zl{F=*lT0_cBfx{=hc6d7Sa8ULWA+Hi&YL48TXXMkKE`Mow3^oVR&*IfIc4ne%c{9vcrCN}uKu&E{Cn7` zwNP6!A6mKD78*|+sbk)ZX5zuasVK` zi*`=h7NNcytZxw*x$A@V+(%fcZn*xHyMA=I6KpVM#ClB#SmV6;Z48GsLPXDLQjrEH z{c7!cuVzM*Z~n+|=XBwLX~g!pFWqgLj!W_{KQD2m=#w;o=&41@KO)&%q+B>i|LDkr zdZGRKzj|d|-)wikUhHXzyH=Joy$f$?Uq8CS5tnRlWT-~UQhVp$GFSR_90l|7<}wYL z2Z44+Kr25(f4LL1OnVFPOmipxyMOD(VhsO>?USYVI%DDj7A$7f0#WO*eD>{R&QE@S zVXWmmmh`k%9vk#hT)>8e4_!N&)p4>VS#WYuy~CUwx~2%)KJnxg+9Op%Wx_;Fj7e@J z>2=CvkQ#Qu_0kyNk^3dirVAHb|1))QP#koD$YR8qIoGXVlk<|)Cx)UP@V9bFOSFtf z)asg_EEh_kk)Gz8dVVg^qecNGrmZ;K#srs2#^vgmdX_tgXtxoYhU{1P6aRJ6c|PRp zIfFV5Je^O+pv_M-7@FnqGl33_W%ZyM_mPv|_ojbeO`CK)I>`m0Uh8G56~+o??3ObN zVLl66E51-X6rr$zbgSDEAE^ zq7@_{TIam>BFx+lDpvT3s237FV*GT!EDr%r^>>Pdg*)gH&6l2r`{+~`oVb@X2;<4D zV99`j(a&`lbh!>}rradgff4p|7#PI5B!_hmSZm2i4lqzsD5|$Ul%U;_M(%Wn9^!u0gJMXQ+XUgG~kvJA)mf@8G1D2j*X}F`9bhz^+BnmyYfmWc-|c#!$S%B(d3@q_GmH*insy1(SM4d^Mh3z zX$Lqa8{pP8ermW31DYRJzoSeHr23HerCnH4=3YeBz4=9_Wx61l?&ly>)?m$;g@Orq zV!D8l6E%6fcE+wlkaxRoXv*2t(C)c~u9-JPg&@PjV{U;H0aHZcRnk9o2$%9r#CK!S zjE0eEhI3QRB{5IRuL0+AFwx#r&BJkIil@A6zSS&JR_@}n2-T@)sRdlxr^d*_)} zsXa>GKs?HfVBOVry>&YP4So*y79s}0H^n=LbmA?7I#Qt`qfyq1H7XGb3#a9kKA7@0 z3%bMN}A!dR>l4@13mEslhiglu*E+=m*$c#+nAEvP6Ui{bj zF31WN_cZfYu@%9dc>uF@e9qu}IeBF)Xv~_#LCl-TzyNKquupD2+mH@@@Bw$Ywszg2 z$!Ch0ZKT6QOx8_QN!H^Ap!bLXts~H{^4Y3yy^kvalhm>X7o0(g#JVw{daHM2(G9YC zM7X3K#jYtzM9!kq?C7PGMfX1S*F+W_Djyw2ukY7&8=39CE6^_QRf4>n{L}CUpUC|O zo25w=n~=(O-siDW|D}@ zyQahHXFe@7f;XP*mcLNey4ngDH$-;(Cz62rnA8EZWvLq*o`%(%q}#s`jWG_SoSaht z$}<3hj`8;*n#nWf*@RzRkw+B6fBtbL@A~KG**u|&spU_%73uJ^>^r4#`Y_!HK*zCQd_gh}27% zIAuH)ZG4WDRRY}zR^oGyX$%g~k#urQ;7a*agzh0X7qM=vOf`2d&oZh9^$tk?8u)Bu z052Uy-VHT_ zFQGeMRh=~{4f!+ZW>bTGBrG3a+n;z_^q>pZNP6&6k~YoA`1sB|eq zV33yw>j;Elb6i9tUnFC=EC@z(*lAB{(4w>olx+Pc}td0|EE zr)l;Ai+XgpT~g1!#z=ox16mQ5@jV^jgKksel#u5vsFsx@ajHLg>Ryt^4zR>F{x}AG z`FN(s2d|`frh%qZ7+&~r=g85wm+oMeJx)($QdEagOiZ^z%efx?usOf);yb3i22UaA zV!_mqNa6WV%uA5=iJW|ONq}+{yVj70X;%yKpmiLP-Jo9w>C;ScseWCSe;oxas^g!3 z-{ar+w!e@0w==W!AhL(QkG8ju`}ddA?`ExRRo>0EPoF$->+WHv@+^aRyY{&qB6{MjTXg4rnwwhd|>~{kgmS1rQfrMDNWSWGZr<}vVNjmCQdo#d76;1 z&hI_g7wc4()@+}b`i(l5bZ;!ky$mVsMXj~fQwaj12lT3SW;*%p#e zK^GD(vf_hj z&)s}uNc-ivPVGg+N1b4sK@Cil8ghe}hu=)%QPbwBLqFW#{KEBzw$2shpd2WPNtOt! zJxHi-(Btrw&h5Z8|M73!BmnX$9bEaueKS|2ZeEQ0&OV+>FJ_8KO@fB%yP_LrGC6aE zBgKch(GlTR_p6c-eBwC@R_38&?L0(rhbQ0qx;{iNrB$YwePCB=2k5o(_CT-vRXMLz zW|N>}UEKEo_fZZkGbU^0b0cJJv&PUS9v6vfxBfGaA+!t93#}Tz=h^xfpLJaai=Y(I ze&?va;gh7Ta<_CVgRU9yJe+pcOQK9BlFgl36`R-pgUJwwVy*?PR29|)qXkWMLu{L+ zMcQZ;G|rP@fPCS8L&bY-Y}-T%fgOQ>p?lE%6Jn}G%t5+Kbb&ftD2jJ z`NR5ZwIK~*ypg#?o+3_|zgiP_Ro~LzSh|L%%VsnzHj9)X_gf|hfrN~hE-aE|9%04b zQ6hP{sNLs;yPpyRN-ic~@=~r06e6LTIwE-W!U1uI(V{;}%K}-(yik>|*-cvO*KRRv ziNr~>KlBRt$FnT@C2ZX1LdlfiGR=l5*=qsT?}x1^C0~8;(r-OmUi$r^%b%To5?Gr8 zrZuWW_Dh_5a(A16%?k2=51K#x7IW8ViOj6vFGL;_NNTt91Y^n6${{X4< zw;p`9RGJ00DMuDb2<)7U)DzguIesL`>bdH$Wao64laP{sL!uf^YUy((5vgUU9~4E3 zCTHVn*_we9gIHN6dc^AJQKHp)7;c70j6&Q-Qq*Y(+vhyZesm+v-t%l}_9yX=DtNiUqgAWuR30}~b%O_<&%>BhQ4C|vsnAG7ov6D(}8C)56>d{!SZsV&-Q|rzhek1!A zZ|nINZzoA30(4-4rZCmW7JKTGhu4G}p45ef>Ta2#QrNmSZ|;MoHF9mHleJzaN4iet zo5Q~tZS#QIUhK7PhuXCQC@^eK&6DzziQ?&=TZ^I((+G|+TvNFkT{^jB{eGCS_rolz ztVaIoDH`|o!wi2!4J|#8+Curg{i3G#KejFc?sVL*&JxL0q(pDVHBD&-lF6k9~4FX!_)a!UApG!xv^;G*pq? zunB@4+OI}QhbcJ6x_Odw@(P&XYh>$W-yYX}lBtNtVO{s&peo$}9n{3i_a6iQ`K|kD z(_2{|PL4+9v*GWGS);3P|FG8N#7Aue6OG~~!0!W#h>OY@XCoJ-ZQ(=-|6KJ+iR)=; zGr{TUJ^!~9DaF7QNqf%nNhW_BK z_72WyXbSRWpHiuCO>D2S`06L9C`(ftR zc>uM4*&aZ5>&#G`On;%krh9Zwa)19?d$@)-9wx$=o4kKGbD~6$$6SK z*_ft=8Dk0mDWeB?h!l;3vt15S(+s}4a**^xJWn1K{tR+CNC^^`Xi-YSCgmXE?^F&_ zZ^@*K$MGz8^6yfWrM3-JJ#Ji+Y`pI zI#11?EV=vBG?M#hxwDxMq6Y>WX=N1FLE~CI`K8rUB;ExbhR;EVL`%7>D%BtMjk}=O zd!H@Eex)GG4-6Eu*0XnG`?9^gR!RJ`TRr;59kkUm?!czJvfkL2BR|84{PfPDFz4ll zdFA3Mg6@@&c+Q52d4WDW{p;?W%*;Fvi}XRscIG`rR|B~2`N~60;54QOWjU&=?@O-C z2mbk%)wQy)kmXtH$X1qaZIpqyH?%#p{`3dSsOdt#>VTcuw zB7zf85g^6`*{*4*c3=A@2nf3Z6eu5tA@1XK;=~91We>Ija`_IXDvVP-aT^$EA-IFo zV=*A*qImH(A&zk>8{l>xYwjqi^f27l6e|mDgIul;Rll6tY=$5m1F9A;T8iIB5`rf} zW(o#!Yn-YDh4JcP*`3e^gE_x6IE zNR7nP$1huncNRMHL37F@cQg9E9wR@F7G!KMNgt6ta=xpAkhvjPXo)XMuVl^y12d~} z3kJyCTR3OD%)Qy1qzQpFs?Ww0U~7nSNnhu(0y4q~j8OBF zVPo^Esonfq1-}B=KyMIk+EFpbk~VbdT+&;$B6Wv_tvZgWhDA!!b>SHe*UaK{ANLNw z=qeo3`~fLU>8vo*agPQq5zxi68*J6{IN+7)E_pqGJ4*xF_!F<$@K@VCBU1O08sk|g z0POY>6!{b>AbklBdPZZjx>C|Sk7Tz}{{+OM)98;vf)d(%y$*wK<}e6dBpHNZozDr8 zNSjz7Wtnov@7RyPkCvArK>DpW+@!(eJcORr8C^p+oAh;*tEzyC*vsi2G%cyE+$PWP zs$@MskBFm1rbpX!p7G@5xjRRtE+cQiQ2v)GkNgs*yLXrY6_zcT%H>qpPKjqxY8^V9V7qw{(I*)GRM9y4s4UL{v1x#>U)?4=pHqhZcZm zrW)vCVFu%I4#F@J<`q|L4S#NN=F>5pbC`jeP~{HsK?8u%9&3g91=7Tt+Nv^yH35-6 zjNEK$BC@dRVoxOcwDQcc&y8@r4zJo40(S-$C4zRa2*Z*WgFNr$Z)WHum36SSsE&refaJRhBukP z7OwM0b#OY|wIWXlS)=x?m~L&dEZ2Mw%LNw*6R$rc``j+8x5fo=7Ai2)K&qyBQ9h-B zOS}e{7Xyrh0MnpJQrZxNg$Q5-y?OdcnoS*4zo523lUk2xD?QN#d4+Z?c{{(#k0(rz zCciLd2S67SAEq0zTQ}vm8Byq6$D|B0#putoemDuq@WV-NK|2l&=Yw#fOaeMw7;AD~ zYQD;SE$!f58zmRkI1})Ob3mQP$k;DuB6yy^Sf9Vdc#&)jId6dzzQ*`K#qzZsrM5N@ z@fPw{B!nX53Hutd>jr|#rOE*YXBRuH`pzy&=_Y5_LeJTyiSO@Ha~57HXO~E;H^AmN zdtOD`;kpeWEd>%IR-}EfE?M(P{w#I+(8YokQqfR2+&P94<3qFloE8YVs5-A6ZMeKu z9#+{K7T+CWL-sPPLXgB38c?Y-ca^&>&h?qQTm!8Tt`0wH#&P7Wj9v(AoW^BQ%&`qx zBRdeZzmADDj#u~yWXEoX!8+3p)I%q%XQu6(&Zl)gQQvs-_1Ksq9*0mEmxx}ZEV(A> zJiLm%;kvpIMQcW(Oq#R=T0^-jX@qmUE7S=!h7V?vB*aDRvC^V{hg1})2q+YrsF92~ zAi$8h%|K`m4!o$wfal^2pZo%95kG~$%)-f;oVsgR6_&t9Yprq?-jhRmvA{j>tROvr z_)uE0AvLU*IK5a<|Kxe)Pl6%2HYeA3;~j8sthUC*@7205W=SBeyV<&b#+@m5e*#g{ zPzme%V{QM=Ki}HEBdqN$Sy-O3`l}a*^)@ynxIqz(Xsbty9Va%1_4-!!F(Q4vttQ}6 zKIlR7fw$fWf>;?_C!eU^tU{caLl_J~3c<(uPouk_!1ymjxk6s+y1ZqG?bznd6JL3G z-l2hgivWKF(a${ZLc*Ikg^?~vrLo?lU7}2$JCQvplpIaS3dktQ8pr~wH`6{nj63%C z%$qfv0X@F`Cbfr^qgC@}wI^dFwYTVz-kjURXuMVMx&KQSRX}ofPXb6y!wn9>%V$Mwy`1y&mHd=2^!4ngPo06oS&NI|XY_me{pw zM8{>L@%5H5tu8BadK@R7I=Xsg3tzu6IJB~rPfSpsm@P;b1gWOU_TG13h2(-@O^^fP z|B(>35{06QHS6|1r&EFXj@9^?kNK-0skw53-tt}C8Tl@wyHqNR?d~g8b*CfETV-(L z=`u?Q4_BgCLauBx0)$xcdS=U|`R=8Po8g(fu5m-fb#eXAx1v&}>h)G2iri zrTSlCxU1!Brjs^)>}`uauH@nXQ8i1p%R*L#@KGwOwwSBM5ZXu0q0g?0x#~IM^w5T# zsyXwu^>(&1=hCzN(X47L=y9;NQV>pdix{a#d_XjmU|QK0*Ot>zar!US+q7-E9WA-#`mrlcUyzj`_eLe_315VRup$4_Mr0~T017CN|gKZ6QoOL$_Jgc98cp*N!O@S?Wy zu+yRXQ=96E=`~HfeR*F#Lf)->yo_e)X@9C6qqfJi#@uHQIO@HeDyN#zM>EFdCOj=HSki&yd2s-sxI%^-sL?a^(1oQkt+kbjMACX% z8?Q^xV`@>GWCoKz=>>*oatYvLRxKvQ)pY4V;)zHEniSz2WRP(GX7i&MPj;5JK#?;b zeRuutp4+67a0|s418Al&GgN{`C|0CQerx?`dKKk&i@L2)m0dNG1H1#(0zVgtj92LA zUFd}Gp|pGJ4fNdKdZSG?p|iVUhCE_&^l-JWvpX6dTW{R_g2p8McG}fV3=VEPPNa#` z5OVK$H@%Mi3SFG$>*eh0${wZ}@Z(v)+Q?cz7nmK^Z&71E;6Fe4OzHSWTVtXZl@S7o zC~HG3i#Bay9S*WVI*zsA?9mL-n4Ks9y4y7(uyAAZ58dEiDCNsP0CReyqCI6Ck`?CNzx(jo znz$B&x!w3fcXV?gT=JJEMH~6xU4~`jSEQnq(FVfSW9)#@wg-Uh;NfMo2TbRwB|W3m z9HHl2w?ad6}l|o zRs$Ejb3U?Oil95>3lsFXw80e(u4_;}{2Vc2EXMtX>O6`R#*8}-pR|7^cqKfft|e{} zJ$34u+Rf?}#jI=|L*GvQ&ScYLpk5*$SUZGE6IMf$ex+dO=WE`MJG#ac=2pr1JkooFgKttE11~{!}6e8(mpCR zD80R_?(ZU!55iML}b7Oxxp@~ zrcC5{yX3DuJb72)y=>;$l44UXA4(bUa9OH~21(8QWF-Z)N(FLo z?jSqoEt1_%+LW!Ae?q=jpX>5JZ=nt9lWswXS}}gzTW{(|z)+)}{+ZXUyYj`^XU+zX zF|z6!6u{9T{qY=+UcGDb;RQli;OL=;&^=)Z;RL6{G^R{4mY>VpkASiPvE{gZFx?gf zFd=>_)s;alW3A;eN#`lQ6nD!`xsC>C^nesAQOE(Fmgls&Bf5o<-?n))w?YOJX^HM`O8orHFnm7F3DCf&8Sv@fb>1xL6s0qVY6y z{!}D8!m&#&A+>}Aax0>3u>ixF;e}zw1UDTk6ND{b86|3IQ(z!wdW|NUvXwRKtr3Or_|U$64ITBGPL?-JVG_P=C(CUoOd+i+VkiPjexU(vt?Mc7o*It+ z%+SL|ILt^1cPHU%F!;BhKoVq!)WApLRsT_IQT5)(_&fPR*=4yQw@0y_HuxgSeG=PI zR&qxQRypsPJPBDPbIt945JJclit{3os@#wmbP?kA9lv^%0esL)W9WH&xoqZ+m)bG;(1>PA|3$vQcUr%$kBeP-&Fd$6qg0^ zyybYo8k6lc(?r`9)@hX6qLc6hSwHRp!=Cqef`-~w93ci%X}eVh@$+e8bhi2x}Hi1?Oj1?Le=w8PglbC zd{T9|vY4+}+g&SO%6!PPiDJmzB~a1K*#StUPbYed&`KggE0g9Z85F~P4MPw*oSIP{ znl7UT^UQ>^Y@JbD{gEKzH7}R+YzL!?!bUem^=EJ30gu8t3@CpBftfQcENiv!D(g$- zHC{SMoZ=Ki>w=KXPo*S>t&4*){u$suESo!VY*@-K8wcvD?C>%T=pPn#p z5Z4qHdD5JGCtr}~vc0VJIF<{e0dm>Hs79RY9czUU%S#Hbfcve(0R>N-C&1AvSQA>$ zgoN`+L@=%K7P^Q+TTHydATU%w_`DLlpVL*FHgs)j_ zP#XS5Vnxkf!js@d!Nm}K?tUFha{E%Su4GQF-XV90J{~J(1ky0wV4B3A!wWdIE=Y<_ ztH;&llu6W@tXOB12P-eGs-na+?WYE^w*rsXR*_Q=oHN}u4X3>9o;z~?RGL3P4o zV21TmttQZ`?YCN`N-7L}#=_bjW;yKG{%3Wva8iYPE~-)^zzL-hNXssHqxvglpPRQ> ztx-ve>H!fIsVIm>{-5K)103o#lpjcai^>45xL4fK!c4bOT8- zUYXZz)r+w#0o=VJM2&kv()hEIYRwq$yE4?47(+vPE5NDTnif<>fXc5NN?KX%Mqu`s z?QoF}x91M`v>ifXZI9qRdfc9RTvU$);px$;7*UV)ot~RI^*CvaM|DavBaBi?NLC|A z7tjLms)QIsjH^}e^Kqa-cPRN<&?DY!njoCUpcbmfJ@KMoIK5)Ux8|00G03HL+d;Mn zK@ufkVGQN0F<{Bl6!Yv~!SAq)g+na)r?X1Vpft0J0A(A=I-X^lSv3 zLCQxTptHJ;JXEc-3+J(*dc|EnZ-6odT(C+vGEU)cwj`{lkvT(ZE{#m-C%gkEwj(nN z^EAn4=XiaOAdyswd`r*o%y>YdbiMkM$Uyk04eL z4rosqdFlr#$M@W0`@U~EGS9PGVCLHyl3Nw%d3|<<_F47_>vG5z)d{hH)R053at^wf zZHfvbOQqHIN3FcDC*lKNy=k4_;qIGfJP|NA%HNFSXa>z^KREN+Z_O^w(5n0d) zV(x(Ko*YJdY$VbS^{$pG3%xe~4k)X~V%LD;63D`o)u#6e$H_UZmb!Mn>~^&F7qTdn zL@9B@s_`wYok@?D%w#Q>i?CgY>yf-lJf2cA{QTtBQL)JOB_K}gDj)G-+ssbiR}?YY0)x@S9td&@0q zU39*lZ`~GUXVj;ZYVC(y!0Ge zt(PD&K~suDFfXE(AdA`Un|rVg))iHZ5ZKet#P9(i!dIhV<}-Lnr$i z5iGpn$4KtiH2hT7JG&4PhV$@gA?|dTAdrNpn{V^xj}Cvhvtf{DWa!C!j_qvNYqx%L zZ+4l9YgiL3u$WAUhAYeP(ToSS9!y@W7ez&^Hi;4Sns|Z{YeNC;m^Ee|789Ci^>F&8 zcl0pt@aklVKLNnxU(rc`07*A;fi{EYJMWlP5cF^uPG<1tn8sp(J9(%O7l|XJU5S2! z%`&UuofsDK%^36|)V*Myy?#TXs`KTJp_Ow6|MF!6$qBx_{AB~#u=6r)`tMq&*$hC` zBWua0-?+fuciupD+2qjVPYX{J7#|RF5Ta&B1C~l$EqF~^fSf@{d;=-5O`;~jnJ^}4Ryf#Fgq_!4BA@z2)+6c>O@27zndRs-tof3HKNsATkEco45uqke!Bk@ zFLUigcP*OwT6cjbDnE3*yT&Vz#jjP#;1>-aiC;BRGzvK3RI~?EX}{D9Q`)a7oVFtM zlr>|ApH?E5KxR&D8SaS(W9zKlK=S)ZKno6;5mv1RE2uuheI6@117_fK(dSk!5qjYW ztW4ntY>!Rg0I_SvIen{a=_4}nMl`KMnMaODS`oE)czwdFZwvVJ7rDL@@jgsAxIvrh&k#ubEN*QHEqy+`%U1)e;GmS6nQmy~xu&!lkt%BV0t z`Rd%dL!O77xdMJ5mdlN`+kYMy@(eY%uidmpPt|9BovUFKNKpUd;Um8MZSf8~bmQ%O zdO44MP7GDy1=C>O=M>3j&e+~ThjNYZ;X%f^<0*$M2070lvFBukjLUtkCWG_ik-S$3 z*Kq*8VK00Tr`WcP-g{Ue|d=f_09F3YgKIN}x zxhj#;@U#c1<_7oKd?ru%e#p&Pc}k2>=D&0^_$JPZ2>vHn0CF&5D z`7rw9-J+XlpLU*wp!)bJ1(kCAK%cmFzW`L}IT774WuYkqh^lZQPxNI~l$yTsFbkjN zIHc7=l2*LSf^R`ckX5w`nK;K9%%(4ZdK=|?0@0X030K+XTcLoizN);o|KO))DRoUj|6pF}u(x9kfCHW<7d zkR+L~4na_F%TljciHhCe{#NGDhQ^DY}L-I(hi#BO;qlCGHVTFVtF|yNPoEj*U zg3W{Zea253-L&Y-7&!$)#z@%XKGUB#M+1p3Pd!p#e@JDYzu|2b8tP6-P##|G9pK#D z@gbH0)?03ksv|c*v&xtf09s{0i**Y)i2u^VIxJQ5QS)Ft~^I?kh0&9V3k;#O&D^45a zCP^!nwmm99xsK9UkAf!K^+W@Q_wypi7gOMcUJ{4R@m5dVbglW*vRiAY5HL77!_0yJ(oKN@NS)%>BX{u_lX1~{Z&#VqVu)NiJl-#bD|Gv>IzgO{C(zaUKi zvGoPN?uWJIFZh`*AOT1`YOTs3Sp}XVDGoe$E?o$aP#l;#mcRsuE~7XMI;O@a1vLj# zYX_5X#-H6_N&Lmvg%!Q!$wU}vWdYamXm^V-%%lc()7J(Tb@oWY;&Af*VzcNwP>yJ6 zQ`v>{7NVDS1VOg4t2Mrm7V$2Ghq*BBMmP{MX2h0xf(dk@pt)Dew1}!u)mAM&xsHj9 zv;_2M@?M+^KBqqEAVfKbanmBn3ir(R*V&D@Kqx-aLgVLSIl1vyHd#)rYtA%v>?(9k zw{Q}DGw#(R>zopOp>v9-=<~;lw8o(Y3B#5n+<;ikz+Y32_B0q6Z{O9^vDUh%-WlpI z{6oHnn~OB@LG$e|+^|MVm2DMAS^E1!yh1FXhb2i6`cS7N(csRWk|c@kY3Og=2UICt zQ%G(m=+w%DAyl5`Co*Bzsf=$KVVku&PcJ!2Xb>V!U*{?JY5UcE@3>t?9HjUMk1~3e z-E6?6)>hf#n-`(xhWj+R-7_LmUcK}15nn!;kyk_OXilpFFB^H{W+_gnE4%5cuQ+9+ zBpuck%~Q?l(I5v{gsp&N8Y$LcJ<&dU7e*r}!b zr{?-cbM(&H0xU&{Q8^j9ee3g0*}xyW2)7Qe!GV-lQ*Mq3a4)c)zUd!sWLn>^zdRVm z2)ILr?vKcXL=pUewsVJ9Qf3+akO&9%_wpS{ZIX;R*HK@ZbKD{4mFJsWsU{=H;79{F zXg-wc3#3VD?tSR>fZz!tb$w7By$!x*Jz#+lJ-G|dMU=18Y7kwp=jO$9?u2WNebD^g zvuQf5g>_J@3{0(oZPRTTWN@)(DqTY8WksGYw2mj|_6(8mlEpV&k8c?7!ISR;ensn- zoQ{Q0C+$_tC5I6%lw@hQ`_g9p18hIAu7F6M{>5F@TWobF94m6pG**F#!ib2Sn4SV< z-`S`Xf~+a5$_Z#}@mc-NQOy_m2@Hg$V1Ls)U%)WcLGv%BG8ftA3$#PPQuk<{ul>Eg zaG+qxTQP=h(6NFnpr*|XU7nYr>${^2ahs!_T>t=$<*-}JB~vwdVEz>5r9e1cze9WpH|)%UarJVOK#hsJ&Gp8deN?RHt2w!=4FMRvXdJb zXYzlcA5w<_6IZyfpPOKRYn-?1kF!>ckF@@P3lx>S_|(D_u}j)mJ(L!l5*`#yLQwy? z4cwtE$o0PA|8np^Xsjl)7Pqx7$SG8KefE}3e(lqxO>Cga39@>%Piw-C1W@_9GL{H|5RvxbDW1lFNyL;O}y~GTz6y%K~)k<`6 zQiOtGB*RR7k2f~j69#IJ77OHk-sSRQUKlzoTMl6xZmNB8pD1|No2M>#oI@F0p-ph{ z`ueyiE{l~SB%wwXMoy>1@)A2lq!s7R{3V6m^I-6DW;ix_6*c&LccZY)=2IZ9ex|+z zq7)K(mcrc1?A#1G{Y~MJPkS_8FGVEn(YT@P3f-@>ZBnr=d{t;K&G6OiUDKeoyR{8q zDanXM12mF13hKqmMe}(X0Ho%8^w;P}P9hxD!o2EuP7*zEq@#*644dD+<%nYhjY`nO zyZJ@?;AwoXd_>TUFc0}F53;(|+LRJAgeD@qo)B5K%JFL;%kTk34y{byvijM0NAjsP zA?7DX=QNp$9*<=IMlf<ghw&G z*xS`99jnO&I~r7iJrV=Q`Sz%4$eed*V&EuKoY)y??Z1S5@!3f7Fk2s_JxCLI;|3 zAiIiI8%-o$F|-Lv?>0XPNM9f04&HnI!5%C;@|nA5YpVV!(#H&v(wX_K!MMr%wVwba*w1M5^exKD$Da@u)%ml)Lax@R zeL*<DCRH zofBnA_25nR&4?@Ekdeav^;k$iX zvsSAIn(|SZ*>c{IN|JoLnxCGX{IofwUj4pnePK2)KXcD@Fv`P!{i;=DJL~Zx&_DRg zYxotsJY}k|a0nkO4Id`NV!sOg+Ah-JyD~WFWj#UY4j)WO=wC12rGapCP>TA#T_12F z0-cYuVBGOPTL3b*ciM6u0t|V?nZY99CGZoM*g8C+1uG&EX#H0?l_P%w zL{O)`+9^#empMfvq%6#rP6~-uMOWcaTB5vs@7R>uSGGM}zpD$m2qYlb@uN zZ-M+uT##^In*=Qm0JAElNL+r$RR-Jncm~VxxA}59I8X=h%-aP4wi-Y}Db7pI0z%Jr zo%uo-X4-Z=u~|uZm%m^5oePSda)F-17c1*~{1<`hKCj@`CH~|^{^SMW$!h+L?1dm< zQ?)F?44-Ueh4xs2Q?8TY9ohv7ZmJrSs_~3OQa<1@xa7H$^%9L1d&FWCeV;YZ?2(7~ z&VBUEg)h13IAiY_xU(ulcl)fJi|-r)2hk#RhHSg&9V{ZH8)okIVAh;bS!<8p%!OFm z2HR^J2HO{gwY73X>+nA5XvyLit6}CvIN(~;uS=AF!j~{qeYBBkd3K0;AQmaVRkQJ*4hyU9RZ*=( zGg!5g>bi`H9*}hq4yw$gRJLDBHUo#jIH=i%q%+mZ^3tnj2m!N_rdkJ8JBVlz_9cen2_`GGne9|BaRW2hP9^j07B(d0S9zss z7g%XDyFvvutU*P;jf(zysIaC=D+9bS{&B|x0+nXFF4hQJ2RMjcxH!X}EY{3GR0=Es zSfrW%1-osk*)Zx&90%HhuD599nyOjNGzth~NS{d``Ih&h8|j=(WxR~H=;Xzqu7O+8 z^>=P0+cde=TMhoZQ@?9kd5P-_g#o+(88WjtyN=ahk6^55i?Zko4~gF`BB5n6 zZD@vUrbTLCoxFnNEqBPU!;EX^;BmQ4?IeP`@rW7>FMIIN$)u z5*aKcJYf5WA5UAVGXW=w{4TB(*Xm1)4xOtL&swMxJ*~wYort|R7u2XymGY&iDV0kI z_MtDeszgQ3QI(KIGW^uP*{%gcZ!^Y%=A*=n--!SjeztYiHm;Vgk2HLuRVUfQAp?Hj zhWYph2$Tt{I=DB!(madOO;_QbcimlPmY);IoXn1vWqzqVtC?kf8Pm@UB0I3f_vf?6 zk-M{*9oeIr+M$YaA57p%8}v$$h7HV<& zyf#4Ks1}evxOHA*^SZINTGNkNCA+A>z_q>MKlChKpgQKDF*WQ$VjPu1!f6+j zuOo$vft(`)DrQ|(i)|NM3uJ}7!Mt`oEq@Lu7}BUPvyw-Qx59lbW7lhR>9%RVv7lk0 z6ks-HJO6p2TYT9m=>ZbfG zd|VLBR1GT02ei22gXVZ<6o91>)0hmHVR#Lp4s&y9B-LWV((g)7xkk%y=AZnI_aUoL z1shKWv{czPAToVmYuU177%FX~=f7$q9y8vkD0JsO1$`I#*luW8W1sHP5xVB8*mGK8+b&XCNyQl%K_Dn1QT@un?6NOi{KudAKBRAhV6c z84NM_LC`2o-I^T>uaHzjA7s&6kd*gDH$hU~sQoQE?lLKl`eni8_Pyh`h>Gw~kj+Kj z0brEJ@HPHMynUbC=~}+yTtdZ0C@+|AUouTEH#1v~_VD0-9UnveF1=?DHbGpU#hOcw`in&MYAhruB$4A!&{7MtbZU{{d3UP z8yG9ThYe`M^46;S4#tZ1+Zt8_sK(ZT3T6CgzVWiz7gRCQasKVgt8R)6y(?kWE_PF{ z|A2C>+RdO`uD0-0EIsqI_V&Yf^~$Mnix2@nSU{V{SaV16B2jyvuUR?+q#3Kbne_F1 z;YgfVbsuK+-mmcx-TXm#I9Q&yH&T=n#+tjx$adMF1ftu}n%*In9W;a+U(~yvXx0s{ z>Opo2#8k7+w&a`i9vend1T&#tz9V>{wS0$9#<~J)vN|0g?8r_4&K!vG`0>7Cmh~pc zMPGg>J>`&y4OWoXW}e2}foy68)w&BoCY9V%sI~2SSwoLx$1&L0jl;-QyKzW0)YN9? zMAA54P8sA{R;^xA4*lW-RP=`*XeZ1|!-ME8znqs@1>*CBeZmb~Bi#7BG1DiY`8-4g z-;8ebhth^09l4cC60{xZ5N4C*^Nq5+@E}KeEj%7ABpQw1HS@%AHn`@*EpulWm>`@a zmyK`L7z&xsEOi_wI|H+j2(96a|6F_7p<)4N*<7=&bo{yZ21u7{gMv8Q=Bq3>@Ex(# z=5a<<@y`pMYJ>r;NPaVa3@_4xjhaB%c#?>I0%IAhM17V49M>pZS0W)y_|HDWhH%mt zesmdcuwyR|Y4@bZfsJLEJ7UE7&3{E_QzuEYJnX7aiW0q0810~qxfTyQt!19wtXc^! zwHPF5RWxd)zEItq@}bNn8B?p&l4!8Z3y(_060oO7_^Nae1}EL&i47?j^cuD6Ad;@{ zm+MhGWNPYG8dwJ8&6GCU&ZGUF{aqSw1%In@<@G>4;5!;8QkTIqg;0x&nZOBc}-UT!Y(p;S$wxHEkz|B(G0&h0{550&Zu2)r|V#`Qe zgymgz97S69fckCFyVebzc(|qyM%#%_bkaB(Phe4U?L5JePcXD){F~(o;|R4V!^*0- zLI&uL3~jFppBC=?2kMA-(IcKq$TuG35+p1sPQcW4c{dFRnE z4PErTCORnY$Ds@@uRRhG5Z^D8;hP#UJ!~7zf+jUJ)9fkZI$uz_kW6zs*DuX>Req0h z9Go5@7>aJQ&BHYGqP;RC_tM8>Rw|kZR2xV*#Kt2GD{S z3z^_ALC?P5O2}OT&{Kn-IRa;oU91nFlr)H-R-mkJND3!#WmbFo*{RLVX6iQ+}E06hnRDvN|JL z*$xi}7kq7bfxKtB3m>!uvr6=0tx*Lz7Ghy{j#R3eYi&=~+Or1wqOTe?P7F`ynLq?WV`5SLUH;fBZn)TMlES zR3ZD%7$c92;S?rkg2-2hb(qH5tds!7o>dKpeW^ z+SO$I)pyW=)9nV9_?!M&_rB=&v>Y?#Et@qAUmd9bXlS5SV{USf;85vuR2D!!Q}fJy z2gbMG4(zIt_QJPkG3Qo6jBq87u=jlX?R05z!v8v zTlwNh7BmCc>+U;HVszq-mtRYXJs1HkoijbL_#k~@`jF6u)k9)J@uPxyTN3beoYcnd z1gJwZCg^99WV;x0^CDVQF)(Qji&TAb=1{GQm>aV6IB%~{YfPF)sC8_OR4f1o8IJMP zGZ!1bLo~~X`c!uO>$U}n-}%|eR`)P)wM8>DT0uh0f`ma!)4}faWjYPS{*r48Urv$~ zx%yhxz;WYSVQqTEaK_KgOa`1JEH^AonG`kA2l6@u zr5j;s4HX(9yQ$0-o7Z7x1j-SaFzHlDW*Q=pZcZWTeg8D=Sn)`0f<2VQ}Uxk0<~rGF{VL0qtWui>G^Cj8WX0yi+{x5^vD$_}?RbrV&X z#@JHY4r?RdzPF=mgih+sqTgy}d~B9VByt*Qf{prfomr#WlRz26zs|GtOzs9B>dW`5lk!NT1#?Yf*t9sb88z?I zl4{(h!p)TA>AeFJ7WtIoQz(lyVOMfZYqc)uxMJ3=i7&^kf+8KRYMCyo8+w;} z!$N(gj^#oeEU)PhyuUS`TysXQE|!eu6!z(FYH<-)j+lHxt_OvTlGMX5xt z?&Z4*2uJT5vv>_!d&S4r-`|8UD}qU~(PJm-U~1~NYO*j=XbPy<`XUHe)Y(~Vj#w}@ zr!VfYtzt#YAt3q3!ko=qx@RXpCk~`&S3ViQnDxmo;2lxM7A}eTf+*&lLNwx5uq8p9)biLCiLh|0D>D|FfQfVS?^+EuEWV{BmiCu3 zRgK9~H`-3aR-+RcAJ%Pev>j&*u@jsT+O6iPQ{w1qn(~uA1^Cc{DS!rTG)Y}4X_IvD zwSQfcE=>41ca4*Qe@fYfLNTq?8v?9fq9=yFENEabtAsgxj6ry_)TPrH%`Im`&a3_7cIJ=q1C45ENTNqe=nDp3`=h*~3{#;7<0cl@=Qb^MLZ zI%IXq-f##V)950iZmWX$*y*^gz^5vgIUetSgm^q5JkBEV|BN##$Dxz3JTp;LI)$^v z&y5}R*t?dLzyJRUVC6$JG7sXud!;Bqd;Ms{^C@UKy)aoyJmC*S>BJTCvek zs({=U5TcL9h>I88M^jO*(Kaewl($qrILqHV~xBaE-zgr&)%Ig4F2@ z99EsV;$^um7&r?JvQtZ$9oC)I%23@|+pXfA?X?FE4B3!325w0Mr_eD5&fNOs;CA{7 zGX%qmaBseO8#dEeHd*L5hK=jyu=VRRmW*|hrvesQA6&q~K;HfdC5Ao&5UDhIPs1=0f+7l19FG~4&A9Z>W6DF*~Xe1lL z1aqS?l52#CR_CJ{)PxYx)zuWJD`P{x4A?D?0~oDt$WUsG$&f}_?ciktgF|9! zR%GS#ioY1h?p~G9fk03k6oH3Aqi>X2d%Q$ZW;WCwFQ@`>fqF96g&iG$!zdECk|mo) zTF!<28E4d@rhWj;4+jEDa#72%kAmt4~<48LV@T!vbVQm9x zLLU(PGtF#xSgd5bnK%OJaP7LV32Syz{~J3S<$qgl&r=IeHlq1i)Bi@Nwn~*({+qM6#H@?d}ZNgvEb@eB9S85gi;v?|C{R?+vK_?pi zw;Qw8_T6f>2LfdAPr(AB*L+RT1Y_wB2x^2f+@xe4vbt-3^^;W+4f(uThAkw5!)U98 zSw@ttCI=fnG%E?I3iSHb&7agPsIDQ+t;XP;YtC!_)N=wZ&s9(~zjCl;GxV8No|LwO zO}4jbu&i>hxT z!d{XGNuYy|bT*}?;8=;aSS{kV;R?R3HSRZi$0qPN*O6>rKXr+5f^iHMS7$ZUNsFk3FbN))ZB-^gt((T(r0q9z~4GYiBKafo0}-0hIR6n^^)vvRZy0-0u#c;0yo%9vtL{-olG)`cMGz zpWOEG2q)m@ptzO2=X z0a9U=c_C%&MK1^usqw;LjEJIbayn@>Os=sAtB#0j&H-t;Ew2dxBpPZ)!HcyWk{Tsi z<(Fm$m0Pq8h6A0g439!w&6@uB=a)VUJSMsBWyz39?6p>9aZYOoX-%y+_Oj;3(HMEEgUI;$F3a%Vz4pX@F z#kV$K`R1sd?s{bgT;bXDlBHZj)RF{Jk9NQ$?siw(3{lJ6;)htEV^49VDKwUZyJr1a zWoER7$%HKr>+XdUNj%^WZJ43T`#;a9i(~yvCN7??D3fyvU?b}DT_TO!L>hn&h-8Y2 zYH)1g#&c}ahS2K^S6HppG*%xCOfua1U18FSn6VxQTzTPX+#HyON!u*j2CQ`?@P@_Q z01lauR1ZKH^1`Cp5V7c$V$H)avshdf7J0|9XeAq16in}zp)(25at*gJBlr>`#50WV z@(Zs=<;7#559j}WM4%Cw^pnkhw5ntg5~%b*%32zNC0a@mDkMH#TSvt*78f%2{7FCD zA+Di7vC=PiX#dzOc2AZe@n3<{BwN#@>8V;;@1&eGkB=W*pX#q*(T6`h5UeZ zYlydAZ`q0fQaPyZY?pVB?lQebO(23yeuO}srz?C-k^}6nksKylwWwD&$HaXHClggI zZc`;Xy`Z;AA#uI|Gw|W?o{SNxgw-Td^Md3ukz+E9Awn+H+Rlx4$vkFA5Trl1K_g1# zqG0;^xFIo$%*HL#xPg^9qgEuSCXHKCj~lmq+<2dVjdA10?6`Rgimt?#;2XNQ2*;VY z{e=xE@rK1hK#xc(gB0IuR=o1@+RqP#pOzNgIwsQ*+Z+xQ@mJVUud5%1R6`YqBRx6M zh+|QGQZzqB1Nd=@<70wN6m0o`v`5%;so$$o6!G_KQr=hE>chHgu8Gnv$KU*@DO|vf z?-%IvlAEoFKfUf_g6^*#sb96r=BuCfS8uT*{?uPB{g%OGrQ7`?!>42Ega#Ye(rdi5 z-%tDl#4a6`;J})*m%LYvm;PU?l9z7M1uuDt_|hMxMBxNSIdRj;c7UmpNhIQ&?`dSzSURiHjfX^4W6fb`sx3mwlY${CDTm-_S>4I-@A@qZ zG54CyfFHk76S^rABKCWf_uBq$MDY06Kn`___~J zP^(6$3Y`A>XDt(_s1tm{>q< z#ZkKmKrk#DK;U@OMF?X{=m3f4YQUfviU)_2u6U1MCM1S?CpxA;QEynRS~yTNoJsic z=Zv3LB*}-|MUJnq=DH2@Z^Zj6WpW8(z2G??F3hQ>E8)8|RbBi732?vaZS<7txf`bY z)MZ+;05!a5LQv6xUW90&z0*Nx&_vNCb0Nm!20;*&d%p#dH;FQonKcBO%&cL)%lkXr zI~~!z%FG(tQyp$e)kW9MEW?bgKnER<-F5W*M~q-a2Y$;4wyJ9k^Ygazh2jPsfMRYR zIbWYg&lmn2$!33Y!{*)R3(a0^9-imHtzM|%8milH=Of$tz9D2=$tJRw+=?yPwJN6E z!(lGDIkdG~BOAZ&&2W&YI+R0eSgzAbpcLKV;eR)7ArTlP`EE6Ce=`k%Vd4?l3#P^y z?k(fbnU#R~z@z%N8Rc6T|Ih0&!h@$iqgNr8Iqg0qqt_-9N4Ea1VuF5knIa-MF#%;` z*NvAPm}qSV{-xW7-DzZZ8tKU{SChUh>heC3C`ezviQq2!!IZ|_rIP|fpt-~K48O*Blhn)ZW7+c>6M{xsEhx$(lBU62|BN~Wk%TvDkVRo zh7w!WjI`lP;0V2>U8k}N>eLEptjp#GX{-yYS#{;q1?^g07HUR1beflq|JN_TDXLR5 zsfkL*us_(y>$IH5lp(_qrRrCPmn-FQ$F0L`SNY|{x-;cVVdB$_q!t%%b;vz$&$ujnxzVTQKzQ*7xk7Q59CG|gbM5e0xka{2FNUr*D6LoIwbnP#E z`42W@B$gkUx&IcBuywDk3m4=%veVqd?KAf7z6Qg3Y$=c^WDD%g0=)N%P+()XWv6>B z^m7J}!oN4?3==3Lk6~8pY#(NO0As(EmY%WG>Pgk_M>=*;3kzYaJ`dlX2Nv1j7+S8R zlMh{UpmdnIH8{5h+ewXq6jCw=v<4U=7cKtl8prZwk^V#TAHi_ERIF6dK^S-lG*AQ! zP>sA_qv7Kc$mpNm@~S2~ZkxTw>&S%Fr6d`$Qotlflk-RV=3N<6vM}Ske^Yft2UK@> z(_WH<<#-dyBh{tu+_Z^X)O<|eH*MNmt`_4%Z$yY8(Ch|{(xX)#b*}VVE ze?+*TCj1q5(Ujc>#h>IX`_LwkB@3YFFt=aPf*a{OFi@mXwJws4ko7Zwd1WJaUN07_ z=kED-)mc$}SpKROnzfz>I($to-qk_^4O4t_#zUsE2bFlttQT!QqWDAy?-l_!Ld!m0 zK9*c6BuRfrPWogj&3CDS_!gk$x0|GfOf0ZaoK*`4ffd5OdP*_xrD%*TvY&aucvHQ% z4J|+c55e^v47furwuq*o6|swQk1f(@sf+52Ua)W?e)CJE((xA$*}(Ijk<<}^?vyv% zdMue@JffjI>N`9-S7goOSOD+Ayo%i29b4SPb1iy@Bvy!8YDzuH& z;tsV{GCu(2|B;A;%#KvnGyGUPyu<1Eb+QRco`XP2zz>AbAw$8~hm~0-Jko;~mGa>l zR6YKc*GISx*@c9b*0Wtz({O0q9}h<8Ivvib!H=g=4RUYXPo)+7n5c*ru|!8}RF*F_ z#3;q$7P(RgyKT6Ue|Y?l@?NOX&&NWh|Lx)+(wU88uKB|EQQmUs)e?P#m+^xj z;Lm8&m)_91&K9T3A$|JASx5TX!TG&NrXn2UE6&^YjGROM$`iNSF8L*%;Ej4FFNZut9f>Om<$S3GD|B{@_YQ1@-ZPE@U_LZZP*a9X3 zzDO>@H;Nu3eTb%5GP3GuN+FUM|C2Cb<7qk7=8sah9wnv|G+-Vb=$s~}10kq2N`1zh zw|G}WqjC(D_!u9wAwiM!b4N!`avL3-2pS#a=vZ%Qbo%w^s8}^R{TkO+%}&A42-(+; zqVFT*$E#K$~41jsa0*W-9b64y(xjxGDrOiMQ8NnIc=O`9g{OHc^9jf4{vodb^h z=9>}>fuljh#;&&!Kx~cR^C-cDOp{GIx+n%nGP@Jn;B5rk#}A4Yt9W$QRS9Wjnu1&g z!Kx-4HXeswcO%hp6^PERjOgsC5gk`G(OH1H@1PLLfonO2(3%)@7TV&7vn>}w9LNfI z0ViNVggO%_3c=;=9T;)*+WhkVdO%&?L|xp#CYh9Ln0*I^2bMNb7dFoL4vf%Dcl>r^ zFiVFd2irvuo&)J^H@D25S7`Q8tJTa)x~#UT1}j4;x{DrYic;kJ3XI-;Q{5{hu^w_( zg9TFb8^y4cF3~gaV*o@;m<@D2p?=AvCCA~S*25pbof`P=9#Hhz~Vn)QG+imYCL&l$kc3EB}Y;bK#}J2y~OC| ztW42;Wx<7oBx*l1H;RmT4oJT2O5PJnBP{T$FrWO=04TleO6xy`0vOxu;$X6?7zuXI zYpOW`9a?ku)?I9u%%=a_pF(8n9g7(Sg~!+H#_(DthYWSfI7t!5h{eBo^)(m~VN+i0 zw~C#eT;jGtinvK~)uWI&4HlMLu3Dct0X)Pc7lT8#Ktn;EyVox|8b%#6KTm3Ds1eU` z^zWg`^ca$@E89taGd0Jf#>5us_?NU)qA_68r1sK+T5IYaql4jD$@&;DjHTnRiJON1 ziAe)>rV%R*oFr+MX88u~C6OAV2EsTtW!vy~+F3d)OU+wGryv{Oz9TZD57K6$SECw9 zJd=ZflZ)_+azR=_yCHcv{(|m7BC2xB_(A)nwQT^63KXbmXMT_Nj$bc)afbFcG&jK~ zC{`Xx_HsqoG$=)JaUV|7%XU-AiAF-NG`;VOEfTGANmh%rXhf{mZnE2sCk2^^Y%he~ zg*xSZq_rrUPpc77Go`G23}%R~FPQWHfj1+92yz5LG%W0L6FSB>Sx1}{qEb|o+L|D4 zp`@2gBXCVYU??4!Q#ej0A`fguSq@t#&=Do1hd$Dn^E%K;z#;+6F%|4}}8OY*vfGtJZAA&#eAb{Ol;i2C;Q9K13_} zG1i9;mt$y&S|P-$S83d$W6QeNysD*hzYYs8(z(v^Er#Ft1j)L>RMi>Yh}BkP5hS`7 zH`~`ZYMXK*zc$rI`$b(-4-@-xaR9()a$g#q%P>sU#1>dwH+Q3^&5it%G{BmfqWfUe z1Cs!?Nfd3#_I$XqCN)Y?|JJJ2aQ})gUZ=TE%=xG&(5m4yd-zi4Z#0Wqj7nkmilYlV z(`VGa@~s)9?FXVD*UheVW7nLZ;c7EzQ;0Ykw4zhvNazURO45)|_iD=v*6y}g8#5OD z6Xk#XZG=JgMVmWU`jOI?#G84i+v)Z?8=6o0=9Z z<-5WS#ZJ<#fPR#hZOu0_UZb1eAo&8NiBhgYmpuG1DTv7JcU5`f;bgydd>?+fuvBRK zBYPPUj?8d+ULajl!0H_Tg$pe;!|gvT@xwBgt*N2+w)`*#8&l-0x~IPAr#UMbHf6IB zhzbv&*gIZ#o4GO=f|G@p=}+~AkUWT zTn2UiYmNnMT4WcKlV{FaO{l{_5|4_KK+%z+NsPL!1lykK;n=QuUtR zq2cm=8k?V;^hv3&%w1i@mvpXzou!(?1k)6^agI$f=uaQ8o(~I2I{qhX6f*kivXJQO zPy73(OSWTp8E{JniasoJf!&|Y$hP#VHw|a!moL)iTCU>fLS+A5F zg4lc_2djz;Xe*OVNQ$2lazd~;WBeNP2pLmWQ|iuem%BHzY*($5?ROMI<>>>4k}&XkGfq#!;h)lfp>A1{Bu+?nnXUL%Jpflwz?%Lp8y!2AOt4h&G_6 z+&Ajv0A+K^f4fsa8Jfd3R=8I>XwleyRr{uEUCMSY=-645p%O<|!dX7-@gK@;D9Le} zl|jmO_DKoSG4Qk`n^s@Aaju$%v=9*HWwrY7(NU&>S zx|{DpYHI;6q-8Yl3q{V-^^?X>(@F0uvB7SyI(Y z7EG3Cwf$c!4ne6b7mc;daK5q7qYBvfr8N(HwQ^ z`q(LWIvGB}2#2Zyo@EhYh!3yA^ng?CwmXUv0TJ>9l7>;xXBCv9^El-F$RJ6Bj8W9x z&biIEbff)NGV|8(h_9hhMYirv;Qop(l|$WgCx5#va(x;f)YA8 z?QPoH>)T)W;yPLCb_iGMv!w>F5nmm?IKXR(FHYRiFPwt>GbkDqz%?&PQT?{~*7 z>mo(=GumvzYTgwklcu9Z_V$-s$)%Us*ZBFO-jD@+-Qb*Gi}c)2zM}DHvZzzFd8gCN)f{e`aEP zdYg#B9e4G!nGos|UgIt7k|I4?-1%F`qx@-x{z zid!-9Oo(zb;Ue+lX=#_*<`PVVAO%>@J1w*OF;&|T)bgBAJJJy0ot9*QPWj2W;#rh` z5%_w~6^-;qkv60u*KP64yAsawujP!Z*$+z|yuX^!VAlzT-|(9|T8Rk?kY5}OD~n4y z7gyNpL@yq*KsUV{u2jeeN*1nqY5;ir-_e(4D&^?^a~YR(Vk85rHS930h(?LU^PCKRGqDda=a8Yb{bGBEPCY)jg2Rx(sM%O zRIgfQmr7|%`l@C>P#Os5CbJ-;rcx=l)aHS$S|pS$v>|3&WO82hn;}8X);B|gmefGK z>@vK&VI8FRGtcFHyMM{X~Xy{fr8X`2J(nEaMTO77Y3kA5U zB8|pa?q&Kk{);zMAkFD+keP>3NV>=uSv@}~{AEH{cG1J%eAv%2Ov_Jy;gzdNnUDWQ zka+Y>d!*UjQhD>|+t0qyc=p+u_f9mP9iDj);x3PW^Woeyt03dd`_e53ska~N#f5kC zE3a+dDZgxQ@Zi3KdaxXe(h<5|zDDwZxyT_T$M{#?s2}PSREHU?!BwzDnVJj(9qLiA zoV4W0FAGS>Ygc%8cp!0nuW4M`Zk$(OU9vi4+(9L+c1mn!)`w7Jev^~oZ*=NK?z@v} z365S?l2omV|74qq2H-h7JlJMon~p61YMYL2Ygy{qU)R6vGwUFZQ3W>WxQ4OEY>c@? zE8qM%hMP<5G8TBy`N#O_(Vf9D7E5s7!B5zvZIhk^yYzb>wnQ~;P{7$ zeU^Zdq%)^z0vdk)lh>?*oRD%&3uw)*dbfP}J_9$2jJunE?G>?U_q^6G#lYotcfCsE z{?~lsnznQUyuWl6)_y`>&F$3on7YZkh|-gyGeR4aG!%B#aG$2if}DpT)} ziY{WiFK-bJVKt6OsEd_RI7E6Z;iBzn z+TJrKde=g!SyxLg)6NBlFwMp&Cz8@E*2yk4#6zsa&SLH#us8PH^}@r8piZ?vQa)=cYDOb>9rPjC9l~x~J!sObh$8 zrXEZ)y=Oh&%L%V$AlWac7B#@-h{w}4ff_{7V+&#sk`+)Oh#vKMSxu9u=teDOU~A_T z#|}+Ef+!RAMSCE7MQtd74RppVNvWK=ONE={?Yf2^TuOCT7>Jp$jA~Quo^Y58kC?Ki zoG+ScDX@>ZG+8cu9UHMCRvA!AEQF3AvjpnL_82YGdRy?eqkFEL3}yWFt@Ap|hvT`R zDYB*a$}>Qk*f7-8yJ*^{re3T`G^v^>A-BE2ESJZDoqBEM83xV}GoY0JQ_8f2#*Ikh zkz71k;q9R{Q9>_KpGMZPz4~Ok+8aNJ{u#gfPFMq;_MlK9WUvMygOefzuQ$OYi&3%Z zq^JmWEJB5()LbNN5_N=g-X(((O7l8<&tK8a(Amu(B-c5mf2E13U zV)$J-Sr+E(2P?zN61~zVn0O+|*)b&`$Hr5Z8I{<0RI-4uIuEeH=HpS|YWDbDv6n8C z-(;g5t0rE-9N6Ut)%+Sh2*axdx~T~2rCE-iSTDw{J8t{tZPna&jSP}2FE)+eD}uH9gbfO9@+DWwxOI#6g~zz9m3fvl@o6DTVK1xz#m<;~ zXJQe6VOA*&^rRy`6AH1>L(C$i(;lwRuTMa{_fyk1dP_Cm@Qnf@cOI<5=YXZ$R zI&R3R?m(Gljxx7ysP7IhDGW{QKuKb4UQk{AcByNLep~_2lc+?saD5TkYJ|~l`GfafdwOPFs%Oxt$L6W#4+I zl|2W>i5)E;)O<2@l`b&CQ%-PUxS-DR7#x0#bw|((i{W4vo}K3m$*4@j7nu7}a?!Q` zCXlHGM;VzmF=zXSj9eCBZuwDQ&eZl?%!T^C4VXh`$?B*u_eH!CX!}Orho6R9qeMT3 zSEaWd%377cM+iy-YEfKM$0^zaYgadoJeR`~>2grwPPDUkVIyRq+-v9f*A^7OPR&5K zgb6n!s+!pNvJ(+ZA;e1IUu=irP;@?UEZF3{F1y257FdqrJ=5JD9?`>5Sl<2dYgU2e z{(<@(G6$&!W=zOaw`y710>D=IodGvjqe|p)zbnsn#AiF)!{2xeA+ z!=qV!j+Y!)o$$oHpmLHk`G)D)LuI~6w9X6R`_UDeDcf;G!jR*L*j`_tRrJUyNOj&^ znz48oJJ)W!vP^&Urn;pwykzmPgeyx(t^oVpLt|j|aL*7a=P^HJ3-vKK8qHPVMi*=)!-5m9VS@0Q1SY?)BHBj^(w)AnE+Dm3b8$kfCjJ%`_nlj1(LdlEvyGBdlD_-ZV2RGvX1umdNj zq+zdq8SwFCd1ZJxlU-^raO`Rq?xKmu@P7SqIRaOU z`ngF!4c0H_NoSuZ50{xp)Ecbi!x5K<7*y=J6*GGPc4Jq&Dp{38+nEWK@al~cG13&S z1QBHen$#64A(!;&;(?h!cI_Djy6kZv>N!^fOv+5?PclbsQDCf1= z%FWZx>+k=oYvc4qlP_A1P(0p=ReraB7u~0UhE1#4CI9i1Qy;hGdHPE(xbUKjv)r!v zNH>r9Tv{FsM=P72_aDxE#?Euj`Jo^B;U9kb(|_bg&VSaf@<-2m=8ygOPwZw(S%31R z>Tmkw>hDbZE9~#I(@uM0`|t6OfBfm~zbE+LHvik|e`omL^eIo-zWsZ?=X<~R`@V0- zj;B8L`+wjE&N}Ptr+nXzvwrXgpZ2t;#U}H8*>j%V__hA!rO$irPd-ofp$!{DC+aH+F4lIdz>O4iP8u0Vna9aDX);1Y-Wur(RJL^Zz#5Bc2!WFDn0m z`x@ncYVWUm zjs26qpYXmSR1;y081Wuhwf?<=_uo+?GK&XQ&Mw#OWcS{`12 z#pg7z_&ig^K8CKjK$0-WhB`YpR?4ZPX`+VFwUucY#0=j!X&-*fyQ0(a{BB<21|Z& zjDrSSoLcaZ!M$k85nR#!Kw?Bsz*rkDMb0LN%@d+>MS7qZ$o#{@;7$p@F@V|;KKKaW zd&%GcUkP)CaJO$Z*KF58c(JY577DB$`Je<@P7~r+Ai3I_K@F(6BWv?seWCy;DR>|L zXl2dV(m5IHo0BNGTq}rzR^;rk!huk<=;@e*AV*hgy+a zBbY8}jKgLBJ`R|o>kZ!8aWGW3#=>VDf&6W5VD9WSn7_Dz`DaJAai+Q3Qf{mrtcx12 zT-tgi4D@d;;I<1JFJ3b5#s9wG#S0oQUOeZ;Q15LEUjK>4>lf*D2@w&h(1yy17NDCU z)#vzsEP%JW0q?>!@UZP9bNH+v`Sn70Wdq&?f_H-1XKbHC8~?W2a^cD@i6s7)>50le zrWl3hB$BB3{W_AXo<#Cvb`m-8Nu*{-n!=Qo&5D`U8UK!IT6xy!C)RJtvmV=)5SAHQ z^5di3YKaRIH_|0d-VqQo`mx!kl_5X=T`%*j(KA&>!C(qOi&qT{bHI5+MqRj~?1g4p zA)7U|yw`r>5HL{}O{@_)vbz>YrUVu7ssWab;VrP|uMalZ9Ha9D*0r`0EBaLfEaAE> zu;;B0Ht7G+j|!}7&@-y523RuWw!r@A`e1`D9__4gYrq`M+kxdnwtWUHtqlk)s;ir{ z;NryzLvFR=B%SlxlF>8jp|DmsF3+mKl53y^md=Hd+fiLLT7lbgw)lDk5l8OadgQDX zj{2tq%RBe<8L-OV;APIKt{Sa4XKnHIS`i2ON9uvLR`^Ik)1ej0>riXt3s;`OPcNhP z_*J77xO-=duh)u57f+u{7Z(7_ad9U{o3`Md%TFIpWLvmuGy|9Hn)2(lBT~i>&!vp# z0L$C)p;@>;!XqEhORB3zJMNlOek1Mp4|8eb`BgiJaOPT~%?zarS41{Gq>iB73IX;N)Zo~aye)^!kpt@?bgDe1R%5S6{=hXD^LIC)18NGTt?w^GV zi);k$)9UfQ9JoG`4Y&`?!hPDt;QnAeelG&9k4yvZgR^jdaAR=KuE*mF;5w!oaKAJQ z_w0?qJ*&p=i|66@_$*w6<$CyyGVTXzJRF#Zhp)`S{eg|a{r(ycFP(>nhi2h^|Hj}x zwZ_BC=HcPQEZnEA4>wBL9fIpfS(VMVhR{}(GN{SWXqxp9907k{jfjH+yoMqU&I10v zjRF4N8WV>Ecn!-Png#s5>jRFW{(EXvTt62T*Utj}o{a(CF2IhL8w7X_(h6xGKD*0ocTEK( zyRqJV;`Vzodp$$Lx&#;6Ecdls)c6o4r0^#YYWvCSik_8kv92>mPdRyA^wzvM-(p=) z9!*bP*CWMY7@k=iK54Xp@p_~w^wE<~ zUe_b-R}iwZhNw9GiHf$N5a znE0bMKWF~9l^Ab(4vdIn;> z>Tg?6J;#B}uYLo_e_W$_24cPH-?551+{o}ArY>_y1@8M0v-dF}pTQAn5^+O=u zcm%s5u3erw(r!Qiv5bWm(pS9{Eut_L7O+`9VND`N3sa7DXP$b^C#mS3cM$;Au87q_ zmQ`33-w=RX-#r5W#EQR6zzPXB5vX01=|$U`YZk{0FJT&dtc~=kt!GDb$`^bpub{VTcLdX3(YJu<*m1+IeAGTz#4mu2d5hZ?5EY&VM=RcF4~}B2 z{WX>{baA&YZ`Z>JZC#|~5ZJ93u8c=30q0YeujZ`Zh1lWm;uSplc(g|Vg|g;VRK8#x z2szTRg}je{sEW+6^~ICDXfGZ4Z2gj-cW==sR87pd1*5QOO5W#7(vYm<^=QumD!!ZPE|{Hn3PaH+5EPZW;_htALgL>V zIIWjkZWm^4Wq3nWc&tf<^HzmN4Ga?&A3`~a9KDk<)hX8vFPX2n5r;&}supoAYxxhn zUEU~`%-Hs$09F#B*(vsO)}z^Y2LpJ_l4N<%2_m0Abn+RE2+m%Yf@7yhy$`b?{_=B!SWI!%_?_`7Yj$WJ@2ygh*?LP?r>R$NYkWw6{jvf0 zL$iQS+Zf<20_@Gadv1&Go&~&ReZX!PCnH%ep_%v2ZSlRcfFHLpz^4ju!+*jrsD@9c zCchRPy;DO!C&CR26M5m(Vt8!;8{e_uCG5iLCBvDsT2-63V*D;AH(6V2S~=6c@W#6r zRLH)Fs=}(vnn5-ft7kwi>@u4&D`2O@mIYu7yNtxFUXsK#q}MH&srw||K{!;vB5r0n zQ{i&_o&`98&nqAeK5t?~1AlD6>x0JYGCzWt&}{IJ7Q8}ae^n!0sFvP&nMmmIN9+ik zbi`(_CbWANgkmV`SfspxUTH=)@KY`M^9Apc9;13!vMjtS!7oV}`r?BkIDf1jnE~#C zbg@+z@(1AHkYM}PLKc-tE%wm%OQY;ZF*G)`v5B~oiQ4tVaC{cT@$-^2%RQReKNa~L z!lO5j6-9m8hGZv5T_bc0J4d)H-*EfCBCa>aeS ztR27nn1rMY6$k&Zlt_E-)ogL+g39p8R+ZVJ!E9wNlW!9=zr1g@viqn^)6-hcFzf?g_n~HShOsgm*5LxbSJkN7L zdv^}kJ$qml^aJYIEa)etxZP0UZ?FczkBjorj=;QNRy{!%U%z3SL(5p4*ugrq}%Dh&e-Uj{T z#h@P|uUsI|hh{-P1n5X16|SGy2K}UYpdHu81==r9%z{24&^(sv_(08K8qBTj3eK2U zfurTYy6vm-@ijSlHLI9wwt^?LE7&%#g1|F%4-U>&aF7brt2sS*e7l0v7gzAHx`IQq z6&#`h-J4UvY3&N0IIjXn(cLwQuAi;o`o%ri(yn0Z;tKAnE4X2{f*Th1;BoB=p0K!r zV|4{L&Q@?E6)d2lQ`;3heqIGW$hX&HaMNrBH#I7_t4*e-v@0;9c2=DE7~EF(;O5y1 zZl;2u1I9BIjN28M0X$oQ_uxp~gTu2G9HxRurZW|6ZdYKFhxrv8t}D1@wt`!zK=(wZ zGZk!VS6~+PYz2;@n`#stnXTZ+;vTHDD=;g2eg!ww6&#(d;OOEWjM^2LMLxfRLv;nW z%~o(56+|+fL6L2Isx_Bc>9ZC1Ag|VA@Q&FE-ceT&M&eJ}#5!pA!|eFkYJ4Of5^TS` zeYTq0sitkP%v7`7uEy;B*=oEu#|7Ij@0hLT4yp+xJHIze?P|zWzR3Q0u&(CVY&FNI zM)x4x`PKB>)!2Mvwl|Kc`vu1@@0_jX&Xe`VEUlUZY>qO&nvd1h+%;RxT_@{Jx7{0? z&djgo?z)-}%~tavstKe#A8DkjX_{grHi&w;IR#;F*1X$f)0lUgln@FlzS^RU-Qg@@+#oGIN*C9PaPkZrKKCKZ!=(lV_HExpH;swlDd}L(3-f(O!O*1Co|n!f@{5 zjI+s{Qd-kmJImutJM0W;!Ru_BE(NOaL+AyY~|%gH~=FrSg$` zJGnTly|vmWUwWNO*g9hgh5y(ZSud(o;E09?9NP&lmbW||J|}j7Jx)a`!br;3{+*Tz z-lWats*^iJAuyUEkfi+8_i;ZyxS-3Fga$;g)U3rgm5@(VDo0kc5kt<)yD3R-_3c@rvJ2 zA_R6=^{X9L0e&-gj5apL+%c9nW)OB**^;AnSdl-5OcP|7p=;FI_ryYjl2B4mp}lcQ zdE#T*QDulCixK zA@s}27orUIlw=+o%w{nVw=4+HUZJXzN z-ISy(SN@fxB*c26JUZD`6QSf~`zIOou!EnL+IaP8b}w$XB~N{prBIMIo=pZWrjYRc zV(>ghkF+CI$*z}Nn{dFAE|Zsn=6Qw*8hVM)djXOH(hR$u$?T|9D7ruOENmC(hZ3N% z^{f~$E(|+~FN84CJ@!XRmqfNv+p!i0MeH$~@c_KWgrLRp@MB9g(UKCh+ay{Bs54P& zeWlJ{jzp`Gq#Y#q6xj|gnv#*P7>H~~tSby6*$yGwkyfyU60X9|*JAlVu@sVJL2Zz& z-&mq!knM6swgEmF>6F^QGSUft%t%)Z7{5^>{8qDh48^ijGzoyLFQXtmpgq`dBCx3O)sTgESz@Crp4bWmqz&UvlavCWDLsaQ@NDswWTZDnf@3mr(&k;yxjtPEVg$s{ zk0?fzn-36(5ol~#Vq{5Tgj97wjKG>oK1&nW4GU%la42F#9JEaPm#T`Ef*3KaFmf@1 z*}Ghfo(DG(Hd2+8Kttfn;bN^X7oPTYWNK=G7}20>G%mpFsEu7gjBu(3VuTe%fC%a2 zQg76_b>=zo&U?u4L(!)#;PN;r*Nx;yDC$1kU`Vq&#S6HPfMi4b8M( z{!LrPKS?T5gWt^OC;0eY!2_CgQT|Of?0SxI=-7zY_O+9byp|lY)ieM-p^=M_Q#et0 zk?xyez=dSGkw=v4*nSuRKIFYHGCnREM6*IQSb)`_?NWXNlV%Vtbta|ngf;m-Jf5Z9 zmRg%tQA{NV4I|r_0lL-;-&?`*4xEhE)eYTOg4TC}d#mT~I2oJ2>i4LRp*n zt^6G*5>$x9hVYJU2?%AG<_prIEEfke+e8d!v@%f0)MK`7=RauwXUM=m@|#K|t;4rv zhw_2Y(18czH*3bNbdq^Z)1BdO=C!u`w`Agp9+ky&Ug8Op1n<5RbSMiDn09Gy1AsB- z#<8o`FW4S?A7>d|Mv4Q`-&AJGT?vH8PsUUOiOuj#jjM7CVYqy>GP^NmY{=p}ew?uq zROwh(z94GGrM3=bt2V5f{_wg-I8Oh{4Dq1r9qFI>8bcGzaGMQ~?auc7>I@velKlp& zv~Z@77V(hjehsPAzgPD}*E3yP* zS?cszWj0-sWw}&YmH~cq!X@~P30DeKPdQ=r$m#+R8Y8u{421+I|6yw+ZvDp^6V{AQ zF*Nip1>9<$vlS-e3p)nW9g)|voRm8y3|V!>c?Db}m%>!YPsVNIou+kaIkhyrb5P^` zoGL}4+AS$k#GPG+gqb4I?9A&}4&}l1B&4bCsN>4v3 zPhfkTP=;2cWD@KtE57^(%T`kPL@6ml+Dj^r6Rm&EiCP?_Hq)XiRU)Hsz+h9#Athwu z9ypEu_VFhDVt+96L-f*QQGg@SIO77xy`kNTKu8)dAEZ=Tx|LF}7{>5&Q{p~l{-O+2 zTGdCsoSm49YelKlN9(3iSD5=O_&KT6Eq|uZL;tQZ>9h#wNZRtWIJxhrh#XN@5jjM! z&S3%Ss{jQ`c^>C=FsDBVUpgEEM`PrWq=h_FXahN^63mu{LaR|I=BtiDONXEBAw?tc zc659e2kV*dNBNLsoN5Sj5XU|Yu!#T1?frMw^ICHu(nm;0Nq*I&+$zW47#xQx!rQ&_ zm=%H!K!qlaMxG{(IRiwMlR2D(wzAk|FUy(lGa1TC6~^Nms1EIyyY@54t|E0NiyBg8 zfzGQe(7CceDnGD9C@vHU(%~!fbqpx}r5q z{?q}uK}UGg54)>&ORMggm{H?6s_3MJKQ$m=as5LT@~BAaGZnIwKVdN(s$kP$`$0o( zf(Zdh7>H27(#S{%D}wIqn>kd$$zqN$U;vc2{If~M^l6Y!I@68>;>FAiLE##BC5%kbJ7Bs;IjhQ_o%>;jHBaHdKZ8&zfP zhli2m6pk5VyVL-Do8YeXyfDro9c@ywL6EwU^*#%7?q|O$K^d<*ABn1)p%RuGi8rg{OttFF%dBB>6ymH`nhJW9!(_z<60Lmz( zk}QV~7?kPHq&B2f(k~afjVXeasi#y3H{Q*77at1eZ?}fPaxTe!pJrhQ_(A(4pXg{z za0+*rhd@l9!^Lxkz&J8+B}34SL!d#{5SSNXjSHJ0@UcDV09fMMfOjN`W8P5>S;-NS zm8;~-)#*gc3k=O9Vgk+9DC@h(k5e3C+G0>rlVE2q32MY$I-tO@=_MT)2%!WkB6Jrj zh8NjL7R5~qg?2?T@y-xah$oF9wf7oJhX%EOv(P>f%{c!_Bh*Uj_D)KM7AX zgWA(x9elHD`!626Hd_6bD8J8}h!4$bn|Z{RBvz1j%!tC6YU;~>LH3(Zg1K*NVa)Lt z930JNEXP$aWxNJr-0Gv0*U}^g&GKLOZ6ymF(yadMI+o_;GfiOgku`zyRRWcUSE(nB z#GsWd5rbx5b0t{t&7|PR=MBtgLz_GM-0k<;`)W(nnkzw+I}hua9J5dCFeeAXyw;E} z6l(p20u`#~1LZk??}8NK#pM97M=Q+LR&ZEJ3NnPdN;S8Q_qcrkB7yb&QT##yYh zZB_a3+D?X9`SPc*NWF@$amH~g>!DNaQl+JDv^}WqR5QWSIXfvL>k5gc3$2m7i3*bN zp^W?sJ=_9rB8s}Ad3yZw^~A&=(q_htkI7&+3p)I7OCq^wl7#^^sp&)~p*}cpxaLH+ zV@5dYh1z6aVtu~77+qHk4^EglD^2cb_p>-MRTksP!6mz&#VpeyWn}l1*gE``nHE#k z+jl>lUhCC7BgfQ&`ly^S&Yqh4+1+DO^YZdLk5&S}gsG8}pR9A{Wt70Fqc^9$tGu#% zX3>*dFp#NCuLKiwn+}uFnl)eYo=CgrnwkVJjpQLT$FXVB!b&pF$_J$ zYo3V>JG3xL6*HxAH9MgB`2V%t615jzC@u0xrc5?wir^`EJplqgcL(C;Q zK!s^tP*Uj1$tiNJ09{in(+sg;hT-^@rtR@9$*fbwKK7OxCW&C%oI&BKg>g6T1F^cA zc1m$7R8IvQ94|#_rY-A_(sBc#gfoY9G{DP*5LbA5YNNoUr4RMth_I4`ARO3h4h@w% zb;bNL} z1ClmF6Go+NO;3!KRQ7BH!>?!Yc*w{cQ>-J9scu6pzC+lF$Yuld36Gd8sODy0TV_f% zdg2VNr(!*9Y`d>!2!3+KquB1Nm#gi*2IY_jn*Gt2gnZEpK-5lg>04!ac|STN|!8h1wxf}T!Fu7 z8rMt3%09ZgvTr(&p@h^K|Mh=EJ%yvr=!XmqSv2;h_?l}>InRnTSS*`@O{_saeL9N`E1F?e%J7AK;z^0S2AE-+ zxVMIQh+b`=FAs0aYx={!$(;T|KMbOnEthHBsZ8TMu!UJ9`hgjwUGVNcuFjc>GcKlP zKuSQVcqzQ3>5`U00L+=gULm7aO)KLhNzRhBa)qw>%$`?zj3Kdl7rUiit4-Fcufnhr zAn*_cJ~3^RoYxgCw&Y9K?uNp4LcvJrs$n*>)Oo%#8iaot3~6*%N`Ijq1}HRO?VaWv zmaJ>ZMzI=k5#qFkW7Mg}NX^?Dw(&R4$Lss~c=JT+hZ8lz%p$=pq7;E_gX_>BQ{ ziqIHVLL;;ZI40=+bnSA)G}^SHSYDu7?98U1sN02P8)&&o>08{I;J~*Q64{%l%Kw$1kaf(* z0EL~6qfm5b2hZ>Y*Do!a9}R7oO_xK4ax+LOGlswUHl$%#Bp0aO*);x zzO>3B$xoE7JUSuoF27X<&8)A&p0`(F?12Jhc&=3z&4lAZio}t}3BRD(2!$}oy@)pu{dA%ZGVuUarcs^{PTu8oVEK- ztvnqUsC-9kwpg_?aCW>uH^i4gUU_HM;7s8rQF!i9cYpqJ$pRDzaw6sVd;YSXptxo#5c{pTqKA*yylJKqQRnDmT51|>#W@wDD##YK>ThSj zy2@(mD4M`N?iI~RXc5|p*@5V&p|`ZyjIwI$Ed|a-y|vf&;Wa4lhAeapLCPdt8^D%mF^0W;cIo*;YR2n;w_Jn4cK9J+Jm5%f`avh0cMYaEEkMUI0l9j zd~0xC^K+Hx4lz7c$XZ-hbK?rzxaDJ(fd#4oDU?KqvMMo^;(lj6viSdqa4b060?-J! z9bTWO`PyX!w_SW7HHbJx%>!CFb{1^{z$2lUIva3lKdGwF!slU!Tfkw}lZ>I2GhSas zh`saauoi+E8yJ9M5FM2E{o*~>l7y)*L;;I0RIDgXaFB&#x-*5urA~f+Rs!Smt<#h@HLIBP`_>=o{U!d2JnkZt1k-mTw3lf+%Vs z)N(xbhyORRFlNF*v~0BILlrUJ7uiYb5?KlngY;6+;@lsYMbSy+bq_)?6WdmtPAnMP zTsY-t{s97-NZ`>6rx|{v!@X%L0Vld@_plnWIeo+vNO=$bu|Z4K$RuPh41;FJZW)6> z%?$DIzf#pxswLxY7^trEknNV{8U~>`T9J}kg|aG*4cOKY&_KlU{6QdUhqtT6%4~Q` zgG!+5bt~^}pmK^Vs5*>)FOakCM?roy$KQ4gg-EDID|^E`8?9{8a)qL;&?hKT=>0-c z7WrB!*)NYZ6^CB*Y8lcWzB#KUx;(LY7-^GCI}5(fOU}{Px!GC%wVi?GSE2DeH#@_B zX_Hf4?nKtgf=j`;MPU7@uL>llc9Cnmv?J45oGN5a@d+|Gl;)KuNY)ZO_a}F*hG;g= zU#qCsCzJ!JH)6Y3aM$7Xsd0{82Btm=4uxg;kE_wtcHgqtP$aa8^^dol(y21k9|YJyyAx(&3E_F9{@>I+kkQM_GySa~vq;HL#6u;nPj_eeKnEvafuV zEe_epK$nP)JBa7(O@c$b=|Y|M=0%KuD?ZFVtFz7~;p)z2&?92U2kSLDhgz4Du1VSm`;|*wq3g3r4muXZY;zM&a^N=z zWs!x~sn!QVO@w7@&f1ZTS4}~12(cC%jbK}o>VP0*QdFkQ1S!SJSYcx`vH^+%`g3<) zQw^y4tyWiSj80U|@&EdJ+r>fbvSSVT2JW$Z#J}Sr+ugC)6~O}w+=hmh#~*es4fWW1 zBBl~Cicqh#A04NY9mFO9K1BbnTl9L7+6sio?}__eT}t(4}9COQPrum!&1gT zRc6ndypQt+i042t)S4mW;2VhjhMa~istPqhRocd2RHd34R28=-t(iRtzNqR{Xoc3C z%KLNBanBt!q3FD9N_NW6_igEVE%H8fSbXVXMWu^uw+w>S>=_xk)Usmpx!DaFs9FLH zoa)phT4OB7|1(H_8%I0rSz8Qhte#r&s(66)1Lq*$6=ztLW{(@b7W1lMbzNQ!H9bmR zHLTip3yuC9oIdcjM}pIb7vuC!FsSv8V`AAgIE7UzoPrqR&oRt7?P%5{W}efwPrUhH zYXl(>xVqfI99)CMr@;Q&`&NkZ9*h4Any*B;s5+2P2w~% z?k{He&wrgEtQcNt38XeiYnbgGJtHSUW8cHioOt@lI=2~qK~C1 zE9+uR^VJg(jL*pCZYBmPD6t&&y4WTa?Se$U``$?;3`Nuc1%KGyNo@N1FX0b`pv{tU z+-@PV0!y-UCC!#NTuWIjahkYvoQR?wFQ&_QK@F~T8G?z*>*fl!>$1)q*yYh{+v1p} zpK7{`s8!k1b6;U)o?8_4`14Ca7ze0u?r?k7+fU_NRVJc1ieN-^xv@n?#D=v`Hw zcsSorq=Xo(lMo7uPQy*N5F_Oq&A4+VqF9+?37g9lk2hNTVh7Uv1BirJp+3V8Q3prQ zU>+jcN)xAFLA5&Ac9b{!_C*bU;5{076js753B$l7M#KrzVL3s;;8j6%V-QK%E4 z_{F=2wc8-n(7Ad2nnR*EbnH~2dBx`tr}W;*h)>ZH74b1W-x%@XEw+$kw%3@J)0UBR z|J!#L1dhM`;4`uZ%s;U)Z3nBcRD_e2s$0nHYWdQ(N+7hLVh||RY&P+Y*>s>uwEeh= zR-Y3oQOd9!fpr8fD;hgs2;`_DNZ}0R=2AH_`3F^z+fL$hAl8)(1r@X*a!`<=O9%w0 zqanW)0k)$EVm#b`x>t`iF#cs1n?S99MF%XZSMY7N1UrXvQ? zTtY`Eu#4KlBw7g9Wcq$)`6MAt`K3wKH~v!UJItd~4TS%b5AwmxOho2XlN><7Asl8n z_;XY*>lH{}U$2nhjq4SZUuIBI{*8Hampd^zAkx8dp_wg?f1Q;PzoEdz)(j`qr0vYq z)N!j{Hh{FCsRb=bNV2V&H5nK|2f3pxD`1^K?;<#H^ ze7R$Qyi7Zp1rmxq8-YT*o-XLBh(}M##Y61Rb zegM*tW%vKH_bvc-R^`3-d)b$n*)z#bm|RHc@!h+$Uy7u1szOvS^Ww7CDp8%w&+M&Smb;pF`b_U zq&HsQQG_fKpBz5*A?atZ4r(!w?2hT|d@#`j1R&^nUzi&t0*5UGT&J|EsvNq@>9`KM zvS3ccwCuc6%Ljyv(0T&nZ+>y^4iq>^M)L1@#6Vww7DacF*11+@b)ZGwiIw)Op1+nQ zI&Fv)GWkY$T9p5V^s&6kl*&n3xha3H%bheExUc&H=ycjeKgVx%)^=_=4ln-eliLv>des@cqJNu4ZVvl!GC1%y`7yx%1(9AHJ(ev26I>lJmO(hWS~V6v%Ze+=-`<9%9hqGj z&r4_j=<|D>8%~YQHxbiZp18s!WM!`2E1y zz_`>P-0HUZ!FC2$!UhOuM-&?%Y>c+=7ZFN#XkX4tGBrAfC7xg$mIE^#mIgLusLtYmy<{>gBYwPZdiO;gnGCc1cay~yrSLS$Vt8mLkp{@0 z4X6Aq@9#{7;CzLT$3Cks3gVWtPnN3_WWnIcGP@GQ*;X2;w?~C#9`4=ZN}D4kn2fk| z!X&*AKOQ7Zoe5+UL1NzVdGy8|sHsjfmn{JyyM@29>~rohbYmy`28s{7>=Vh8Q^onm z&?C7z%?ZDCM$;zF%+y}RpbD9$xG*-;IGKhq%uPq8K{Zq(c_wM5O(0T}O0&mNlg%C} zLn1yjojJ*nY30fAK}*c)Rm1;7$IafSMR;|;t8bNC6kv=L^^S_2Z#CU zhdZitXM!OV;4RHBJDDtA7dO9BzWK-U&3)yYulgICt7PT}opG+Sd0uzFS_;Nmt~J8)}BsSzZ1K2aGvR0}l`*=`<5iBX|?I9~WmO3W;o+Rezb#osAR%II{;udt6c}Mgx{T{s)oEe$ z3@1`|2Nm29H*QYj>Xt0E{nhX;wr6B1;*sXLBi>}3V2v7^?j$l1NX^@&jtQ^|D@6Y{ zC%%}T$_FLNc8pts3YnBnYX)4^tmb;9qWHvYFNDIfDpX}bP8f->RaMurRV|fcK(-f0 zbG|NPx5jAPimD5H;A6Ax%~NVSY0dRXG_-TwutDkj(ncrkKM)T(kMfj>%sKl2tEJyD6J7t7*eu@}D-`wFn8!qL!bDpL9~p12g| zJPEx!#d`N;vbh%B(+&MQMg2Rq)W1{Iy7e!fr+>-O?`0v zfTn=yf;8fUNp&B0sWMA=00?3RLU$j!PJSt#HcLI{nvR<>uQVwEu$7|Y2M$;%V|1LK zqT{%vXMvF?fQxSMZ|EI&{=fV_VkD$t(hdT4Cz)C2EfCGa{bQ4jekdU%=) zq63GXb7BMC0%mCmW}-N`v++{fK`mHL-kqHaKS>8aloLP38_wuv5GVkYjXFp#2aigO zHi`Nd+8nst^yUzlihHYNWV9+Mw(-ZrG!`Thc@jyYI2GG75~m6TKqMH;*;^c7%{L^7b*lbmy|#d3pP95r@S=9jm8Fps?b4?USj*z1zEPwBBdkYyR$rP=7Q{iKfM znW+iPJ~GI7@P4K50d-B>JV;{**~z{AO5^WVbT9$)lVoYq(D)zOn2eWHkkBo=-qjLJZKmrT8Osud zj;WE@V{3xyw-rXs6LX8((!FU5m3->W(g2tnk}Y~>?9?|`#eJi<49Pq!PKaUE%CchS zn5l*%fLS3GOTQX?R^<#?UsEMth}MUqBqI*sDHtz0KICb@@nr4Q4v**o(FZw>N2Ce5 zi0b0#4RI2w7HxTqQx)S>4iq{T0>+RLs2*Y|a&?|8^_dSzJ)V^s?cf}G zV!jnAVRonvIx85i<{wrdl~Q6TJgLu|C}QZ!lPo~a)WL#!C-t=2cx^4Ic2c6T?XKeO zCH$IUO+zf-!HQ^pn}Ae|)hz-`K+X*O6ZyEg0-DtUd@+LRp_4yt{xdxEh&#QVN3S}x!ZC&Kh`kW z4Ihncp#bnCE#cO0r|D67IT%5(!D^u%Eh6zl#%e+g-4f}nZhhkuTf;&_NII*WbD5t- zFox$xF1A>U)SX)07H@EQj#ZdSRbZT=BZ16YI<)-zJ#H}X*<)8Vh z?xyJ~`ZTtcRvnE2&W7R_XLL8KJeRFK1J)fr#uSqVpW@EHO^Y3}J>0Og!JmM7>Nh$= z%MpFK2P`Q`ksr&?RO;3N*X!-aLX#_xBE~n$`mdFG1e-JKFz56;2-&iViNzK>8*7cX zNNd+Cs$hc|046fWq>+ zElrXwambViTSy#RFnnq0$$4jb*7_w&n`rRq@cN{n%p_2zz|%#U${*Nt3irhBhzs-W z0SZ$7y}b7bzBt40lZ;TQ5wnPd`Z)Aqj!*xt$EU32IERolFwok&(MNY~FQ%THO*9H} zgpoKO5MX+Lc4;a4%JNmmmN4N#6UU>3X4sO6LEn>=9WwfIK;W`X9Gisa?}8BNlBaEZ%4v- zms}*Eu8z(%aT5}4bMz0ju=?nxF_h!fTTKP=eH7y`>Q##AGNn0bIjJS-S#^QWll z!6+=OOYOD{;%NwWfLwWIF=Rt-v3P;|N%XTOOB^RYDkV6{`Vso`a{2>lpQ-+^!YUh^ zARwy^@}@A(2=$}+_n(0MY6=fhBlCb`5ytF_Gg_%)b@XTLg)dfBN3;o|IF7aam4vZy ze{}00{jBlf7+gMwg?mj-+CgVCBV1IQj@Sc{Oj}F8sV1(B<38pF>!W;u3L-e8a30N& z;-ix1WOeeC@d(iOjkSlf20yZwn4I~X1_L~6@Upd39U5sZ)6dIW%Ozv3i1lw+ z!>?zHHP`D|Q)0^U4dFGE7m%I*2k9!wmL8QhvxBpR83R3-H}VQ3nslhE;yjE)1A={KpL2{26`YR*2W`i&2m($o1qJY7LA|cHmu0RihmK{#;yd>EaN-7_BKIbQ6Vw$> zaIipF7bz{*+b~Ye%PV8oT?xi;-mfqLK!qjtJLpZH*Yzoj8<1@?;HN*6Zyru7Ezofw z;N4+VpT0wyx^wu)V_tzx8$TXS7IcKzy=>|8QcSf_0qC}6e)eL~T9nHOOeCkiYC#;` z>~B@U{`lGl2`q;!K)!YpA?NMSO2uBtO@uE~;@r+zGEAi-8h){ZM#f`Zvb`T_bN=2) z!$T#qnWgBMUfGx6h}Z^}j0A;|_%ioEJDj^%q;ClpS*Imqk!mUR6P{KqiVYUo?~Pn* zO-8Qj7mL&}B9zk(9RAK!HEvL>nUAA&oXSc!eCU}rtjI_A5CLY|_o?)Wy{fsYs~WfN zDE%Uv5k_`G+mcSs?#Ck^#r$#oSRtgs>1c`;Ntq>9$O!s@vu#5*a*|1xS6`E*XXpRp z`~URte_L-xt?b~se}Km@%`emj%=qM$`GvMMj%pxNrQCH)PQ%fIHWZp?Vo3|zbuv?K zLMHUDgq7Dfx6?7_a#k0p4EM8gJ!8N*{k}%k#%OFwAY0J9MW(Qfn0yO4JP|T*EY`)@ ziMLs)78f$8fny`TE6g?mnVn#DIwqI(TNrQU`t2>{KDLvBG~8J3{#hL!_nl2i5uDXH zJYWO4%EdjaSC z454R7m>Bk{O*NY#41RP%8W0gxL1f{4G*e7ci*3z%OqUOq;+tHJYNhiRBmq*l=e!g(Eb-CZs}YmID755B81_G;rINM1HCZ9$E5_vGo<XZNlkSHav2<*Mz%r zE{b}jYxwRsK2tnX7dR@fh10l@a?g)mXfqkTO?-wKeS(|VGV=N%Sgn&b_Xt`F=uNbz z@$fPvd31PZf@&#hwxHhG#Q`C>9%b&ZL(~JJA(tLyF5XQyyyD@KR?TkfFFI$Z>da`Q z%n^axOIpm}_HGOKkW@|bH1|+73!U)OcZdav?V0G8Q47(b$_>n zS8w_vQ}PFF^>+@w`S|2T1ugh*I+8`C+~?Peg{dC2^sXPz`d;aR=P3QU_jM@GP||4& zJ4@+}CB>GT6pQmmSyWM+JGf=K{2-?Nfa4AsVJj9SGr1yO9&$)b_VU(XHYT!KcEpLO zMyF!3<$`A3yj#QQrkpEW4AX4Vf#-Yq;N2+QnP6qUIX4P(e}IN8e*+}n%NnVf!=_}7 zxCey7$Qr55bl8+#Lt-mot%X+Rv__!B!Wx;&7Pv?HZuV4d!Oza@(7GMjFc+oH8z>!yf!- z%UwnXUE&&8$Ums%oL+&0M(SiSo1YL$Sa+N+G4En0Wi^kV95U=+nOR05Xjt5B6vCH; zLk2Rae+uBf|3`&E=DlZZt<^@nxjuN~j1Pbi04Y`w@u~auLknpok%pdF(*AbM8Q%D2 zPJx)18mJJ6OL_fu{0AX95@j_U9BN#IFBO9ZY+5K<2@Rf-TsXs6wPcIwFee1yI8r)$ z?6!R3?{`f2D3prT!W>~?hU#De*D=$20pgPuYV3qr>UO(eovz^{ccvNNh+vx2lB>O| zD9gGuC)=jBPf&r(CRmO&J_l>O`dcMt6+UIGil557zit6mlROyeh|7 ztt9L84v22>zn8>C;X@1*k+C7UjdBRxx$Yc{fw^VNAgvSXzNIO%omBDwDwGgl>$6qK zdTy*PuFsGsNG>gygR+}q*T9PV;!l6xy0Jl4pI5Ve3%Ls9ut&hlMW2pSyNTM z2zne5uk=J(sCmUITdMVonz`(j^2@;?pl3X6Ofpa0GL;9M6znF4)e$R5 z$G4VgvOIZuSgJY(@_u0{Tj~kg{QH2PN19;#KqwW5JknyRFJdL4BV!_(vMNnMy;JNB zv!h*oLCm(g{4va|n36-DSu-pk&4XFY~~2Qf*rB5kWn!;kI0o@@RS0q_-wbt2K3#o z5tdX$^Gv4Wfj4*R986NCn6~EeBd*9$y(px|!pkh+K2Y)lSd|)%pe4W4TpxYtE3-IX zpa>d8{@yS6W`>alOG%hqz1qJ010BQ~CK!o)wW4fPj8(}ga_|~}O^mol(xguTvsDNA zKH|EvWoNmGunxkL1FT~@tdi-V*`;|eH5|6T^hCJZQj6h&luVCN38arALl`@`#QAq3 zvF5d)1E$;qHO_O?DgKukoC{kIXt*n=i-##d;R!f73-en5qbjO zFhY)OHpT^bi`KA&UH4XEPNeJeWHT_#7$%Vn*aDkRECA>9OV|XbOGXJp&wfE+XfA93 z3a*VM0ZFkyq`Vk4>nH{!)0)`%o;G&Hozt}OmsQ-fH#!s9sI*c-WqjTI(w&f)>8-_% zZ>uhZh$T*}=o@&SecFoD74f%NnnncR(HFHiPK-W2b~v}<o*I>mERQU<0tI?Lw6(4Z!)J)a7c|0GK{*0JeA!t#<~Hh5NgL8=Xrn+Bv~%+0Anw00~+2&N1a5*cA@r-G210NjXPVBE)e_EyzLIi#Cl+>xNXa!7V?E@ zS=fc|DEO2fZ)Wdaw6TcMB_WhJW$y)yPbr7GW8JnUj83G8-9PiYdyFddPp>4~V(QL` z2VCUsw!K!0aTj#b7sO1XR-$*N+CtM{8yCOnUk(+|wk;x1S7vJhI_V<|yF2*M8t!_? zwvuhXnk?@`T)`TQg=(NJ*4|PznoL&bptAx2$sb*G+AJs2aZ@$#HQ-8TN(1&dU zrM|&DY(ba}pEt}dUI3N=D^2=gX?6z!S^_$bZw(oaIJ8v2j`PbC=j92Opj9=3Ksw%^QRr38ig+#@fq1G{v$ zVr_GP$(@SkRA09_s@O<#P=0}Te8H8SiQaU6&_(XY98U`GlG6z%C?Q@Zf-?WRhTqN+ zYoIFwbvTT*+s`~v8jX%wQ_iO-iz%+tCYTb=KiW1|Hu}&ZEf;rc zXUjsoA{%)a=W=Hh;@M&|4=m9fp}=;TWyE3%$i_oaIfS0$^<+CpYdMclN@dUI@_Ayx zmzekCcMwnJwq4j_&phu^PH*^1~MVaIy=MQGi3C`M#%qGFkwyj4g=l~QBrn4 zlU;F0trbt#gm<-vNk89|FMHC$U0_`Nd8LTtzv~PJk1DA3)e91M!0T{g)0JH>vm1Ikik@t9V|r}AI4a= zR9DcUdq7ySp*vgdj3;PBFUrIm2pNi=gOKYMK`NqWNVxdqCG1mZ>WHQzb3~^x;I8#l z4Ybupzkg6rvu1?ozU0CmR=*_bmIpApp`{BFpysvo`g24XVX%O|*ky1(l4{waj zsbpCImXuuseuIHj=i5*5U`f~a=duq9JX-omj_rd%_?oItJN4+1Cc3Pr7W$M>u&un$ z3!Vd`;KiV#x4vX6@LpfCQUSpr>O2&4 z5Z@4D8dSPgFC(dRCc%@R)IHU5i;+FZjsGCcK$jJVWg3ZY=CaLZ{evdMzeIg}`#~nM z_k|9jJ^%}?lW9A(-594v?6|yp%-rSK@^R+!^6|E9(h);sUOwmrEv*27A-5opJVIl) z>27+F5}V=U?9;EUT-V)pOSgYQvb4zWF4q8rNzkWX!&Gm@M#PP3bdrmT4WvCV?)H!` zQwfccd~L>P#AaYYG?rB?Oq(MxmFA_-aTcLhgY=NGmwn^;UE*T}K;{PA^<^Rw*y;j<#MI}&rh4Yvm* z$k}A*?zNAEuQWn^M7_Mjr?@*|G&%^}Qjz#va@ZPuK2V_U6B!I>*2B2@5kjDK03pW% z%KB~=#L8SlH9CEHR{tci<%V(W!|^#!SnAuT{uvqjouN33nx7NDH#zUcHLak7G(V%~ zz{k~L7-nM&Uu1Ff9{-Kpy~}Ax2yeEXztLk`J%yKw&4=|BI&6z+?1ed0rV7r!#y@qO zd5#MvBS6eTDnwcI1m8T*L{{y@)X~Hx=f}n&R zG-G%%lds6)mClvL3-T2Y2Kol0eX(_CRu-@HfU|gsy|59$XOSuA6+v}WW|1~4D$qO> z4+x!3GDjA#1MZ7qsukNXL`1!_c=_pT|pQj_%<%Y}`09+2dc5Rggjk9C`!$BzJlxzZY&JBKxUbBTEToTjDrPWEaj|+W? z6^2#OuC}gwoAV^){EhTpP8;Gv?P7wfs*F1l46WmbovES5>+I4hyOB$=g$bMis(er9 z)pt4{5aJj*rkGW;4lDT;ou?$@^G~VcQGskd7oVhSSIDIdhrWhiu5Omqbc3GJt*`pu zhxALOKhQ6<$9lEhUm~z$ri6Y=HTG>|sDw+TLMX7C2C-@F;~V|&`}NDd$w~d1RA6o~ zP_S8P-XjhIyL4>8g*=>ky(|R8=9w+6znBwr9~!er<|^p^aG?|EH00g)OB?;B^adNz9< z6RD%|nKulohHZ_u~)*%D~V)yKrWH9c=S^i3x5(Fw~=!ozwHpm7e$~( z+_&b_uH!^qkNhwGQgOugble65y|2tqdpX ze#oD1=R_-ie$qjN<)5t8!=E^+S1V~^MgcHqKZf^k+Ru&+ze|78tncUuUWtW5n3}qh zHa|Hn0;{vtFBu_Q+MFLA6T1&BWt2X=%YPWoLYn*27g`{KPlv2eKjl8fsq_t`U})AgX%fTB98bm&4KSjUWfCQ}OP5UOxe^ zzgFiubF2T_EL%rh+>@f-yi9=yGEfLpz!?L>fv3}}{LM5(`TVs&p}BL48(~(w z8~h8FGHqgY4ZF>l0$XlqR|KsH%uFP}1DX;d0Dm^y@?_kRTUs2grXa33S4 z9YIjB=FLY$+ro)&_K?}lmTHh??)xTr`ZM&v5N1f93GJo6A|I;fu-iO@uw^t~JG zg#G?C12oe)-|+!14e|zV_t7knUpxoM4}9#is(f9iO8T3Pc@AH1oYKYiYW}(BIA(ru zJ(J^PRnO2I@%oRV#!I?lK~n!b6&~0Nty-8_;$krb2G>m88e7!-S7VQ$xWgW!#(S%2 zyd^%rNNPloQPovx$ia#cbF?^3s9V)?9lFW}X)162&?=U2baSx$Z^0hrQz*$P@%2JZ z&BY!WNqj^UIUmtBo0dB^Y=^190rl>;;$H9A)XKZ(CQOL(ynte;(bUh8|;^$hv=hIS1@4pfHTG42{C5@8{;Z;t%(I!YsTbDdHsjyb-(I6V?2!ibe z3vtP|J5$MNKME#WP)o=mn@047bw5-Vs|k7KwtY!nrL^krX3DGT6OmWUBgq*F?;f%$ zbg_3gjD?3TiG^dKy2|L>j9zruHxbVT`!*%eNx7o+4%=4ih|Yhx>*BJy369`^O{j^2P=#UaDG?5|DgB-Z6zt~OkFrW>hI7jNfgOMcITmq>=M zjvoHkH|e7J{T*U2Chw)i`@+MD7t1f+B8#TleDrT919`iCaOidfP+ZG&$MtKE6c0Zq zc3aov*>Uf7fL2?!s9XzOjcnB9c422=N`K?#b#JsL_(t;5&ib*v3u+c7*Z5GHDw$o8 z2@Tb_dZ?HjpPPf-1hZp(8@71>8OJMAP`>+Po@Fo=Ei_f>fYYp)8+htLhGw30FZRD` zGg8%b`R12&K#_XJ6e9fDbZ94R(0iI+)?1}Yn+FrZe3iM4KQF{jRPvAPWJ+jT4N8eng$cVR;4l0Nbis(N2P3xL1+@js ztIl+)1Ph8^5E#|a1I*_)0{R?-8PSPt{uv^@$ zb%tqoMyPd1sJ58Z$%Cwsu2KGCrY376mQr|ysE4!c@;f;45HaB<;3(xpAQN_;flL@U zjcE5Cagr}%ra*8K&?@ALZnvTez9m>+yQKsLO?`jm||?~+A? zJJ5K9no``dcm!;=phyuEu-0SXN6tzD!vy^@U2(*yo^!OQp5r$5EG&L%mF}ld^|(sM zHyGdI^#`FMpBWq@lb6Gw(Y3>0x7JZ z*cfbEQSB6A+Z@RW-WGR6Dru66`Q+8)bs&b>Jz#-U{^q`tzuBZ#ISfGcv)pYcWBEVM zI7D0#{`?AN_?cC+yo}oU;qb5Z3C7hXgiAs}os9CY+#?;*M(VOCFi;j0D8pW#F>T9e zNjb)4Z6kJBT6EqvIoGt+(5h~%j{GJv_WK;q2b3iX1&sjskXS@D^TF(z^~h=#4GIzn zKYH!H=2FH71;T=$8_WV!6;+ndwh*q&8u0F^-4}PMez66H>l5n48GlgWYzd#xTz>CC$-cqdk=}^7?*nRP~tpDPyZ@XKAvCY4l z7uWlzeOdpp_4C{P$F4;&6qoRAHQZKWsL-_q!TKSZwgeJTYcws`g2qbh^~bJtjfk+7 zUvaLCCjU^1Rj~sM+1QT5nh!{eV5*cL-9r5T;={l}LDc(XD2^G)YXyym6#_U*pJ`AuRC1Iz-K8DnOlDABl|9ty?_U{?8pz&9lW4Kh=1US zP1&9^2a(?N9!(p!Kqds)cXpDx_B%;Uz@e^)k*vp0_n{{w4V=qx{-WS=Z58 zL+^Rn(TkZu8ynwE|NBl$urYiHkF8PL-b=zL-wPF>t{W0gcJ0whz3NE3F zTsOA$*G?akM(5UnV%Q^G6xN$@TtkXTH0w~XW?fdSOs+PRntmM?(eEQ&c%hu@SUy_L zh|s!^jn6lamiiEF%QKb=sQSc}*B`s)VmVi6&#W~@#mkEA%BFRbQY8*!TPaW3 zRvKrdiy=3IZ7Z#5yiWhKteLKQs7+Cs=p3cW-L_I>q3@Cnps&-0@XA6suJf!;|GDxi zximNcsIX$iN+SniVy-QSpFj;C4*^BVAJw?70=kX4TI7j47{}Xa9h}wzPMuo{9tYIK zBY>KPrg4qe6etl54vDjf%|N|gUn`=*YZw7-7v~KD6BX{`#^q^;`7-wVVd@n4BNlo-oU3%T3|1B*U0}HsU zLe~YZmgWUNDeN60BpC;jP=+N6xIz(VA7xs*Akeeuk*(1*p+K2AzI%u|h6tfb|7K~M zG5Q<&qVRG*B8|;=RF3y>9En8I)RQDk9>b*M``nIwz z4(3C5cGMy%o-!=L`#^*z4`q3FoU<;X@q|(r(Re~p{^<6ABNe5!4p(KOsd=Iyw}8hA z&g2f!DAP6fT|`5{f@o}O0UEy97A_P}uZ?K5K^!-dCmJaq(7h*`u7p8k{}$2M$_t#p z6AeA`M8i61hiKpf9ikyryF)be#r7n)5rOp3(JrE)6(bs}-iW3y%)$kXcyJJT`tX?0 z=8b}kKnxUQ9I*$<&;eT*3fme2$%Ftf0PJ4%q@HiGK!RSEobMF5TiUVhTXBJEXj}xV zOzhsLKm~?oHxuWxRDJDP#bQ7dwWQ@nCn+f8ndzhd{c=28(EH@*^3|iK{kYXXGHEJi zG^M9ko709h{eAl$Pmxf*)`|OdQ+)3~{n1)JEgoikJ`FP~{*Lzl@TWun^O$7q^ynpj z6Q8r^dnc})oF09_ThIL4RTo{ei_4ddUb5h2x80?u7yQ?6r;ES%d3*XY{kfB;p{mh~ zF8$39-uaOaQPC^nH?Le@`-aMW@(r)J^6Q61BV3-m`VEKtU(Zi>a~av6y=y10rZ-br zG*#{^qlu5*@-ko(#-4>W6Ta}@?pZtCj;^wSFrx7HXCI8O>d6gex&ZUkq+xGrVWSwU zM(M_Feb4B9^%n1z-=%>72o}!)Ni_^dzyHxgnxsoMmKMA+YJ4tEV)Kt@QJKtl?MqJ* ze`b&!0!>8rZ>})yk`ahobD(ZqJd2E)o3B?`>ge~L_t@jd{^mDCrlH*I>EYjP#rLcV z)lwjZy}NW*5Y?{9t9WKYjSwzy9vG9X&m3u2S)g*}8Avu17Rm`RvMbqDzi`;HV3W@vJ?=1@iv9 zO;kf$0Or~(YQ9t8n?cor?UR~4W^nSc`};GKJu)}C${msi>_7C4n~nb#_{x}YasgdE z?Wj8-@8-#=mP~J7@SAJ1N@tQ1zB4(cFDKon;iIGJGw+zd=%tfayQx1FnA$hjPTJhb zqMgR#SGt+>&U%$qb=Fo&>npqQnJ0(Z0*gdR0w=r$Em6TPZkLA4_bj~@6(>6WEH|T! zh_wDpDT}YB44Yi9Mcr1Jt(tY(+dTm844cXf)J@$nR zAt5Wkv1=Le0O!r{1@;4S(&@YlDr}vIS#Uu{PF#tMEJOq#MvD!%yNd!-pBi%!;_}Z&v$|&3#}OY0YFE((HKx5dVJM$# zJ$uXfUr9#PX4)9_x7|Zwh>`!J5d^4Iq8Md8yqd5IIu!>ox?dP|##Ma$1mPs$kVFXj z1kL{mMy-l2F-*B`Bl|og47k}q*z%tmF3{wl{y##64ugpd0~t#D)sEi;ia}WT;fp4O zwVf1|>&~|*fmC-2|c*+)YZbT z%nc8^z4p+UjT3bKxmQ1SnwI66(N7WUVZ3EVA}5LQ4?00}lEMrl&Oi3mFS~AdA<(=+ z)3_Z*jGo4#r+HW&07kKW%(_i7d3Dh_C+=mKe`%}p!g&0?uB$2$OduUJ-|*FKU%g`c z?5~QF^fWZI#d`Ah4|bQ&w=~~koJU@)##f}kr(3FJgttrT`^VH;NqrYbHHb`>n52WJ z;dt#vY4#Up26q>4IsXg(Adbd^e8dc^84G*5ip?mzZrt_Wr9!UNubpXRp< z`079`K3T}P58nB)eIl*V|MCaJZyeZF9g##0P+0p)vd?1!osF|d>(SbCljf6_oR_d8 zq-C1#DDJd&WQ|3mk6-l6KRJHM4^eRRO@2ctGuf`bGk`l+ue0iVoohwn>s$rqBsaCI zqnnTZZ_oYS^S*V=G)+|bV2|l~(^?edlPN-CYg0zIzOsnE#IX!y#*M98-W52&h zR?TI%+`4rAZGS3j<%NY+Gu5t6x8yWV4AC&P(9G`1tAok|nPXa+K-0h9S3K`U=bpqa zuY7pZnC9^=9D$55>kD6FS5IAyYT){;c@n9SeA~H&nrs{O7)2OmG~!A>`qq)=n?$ol zFf;BrK-1xy4OPaQEbdCw}e#Tv&3`cCH3{#05cK=8=wcQk~#Wa&B=okl} znZyB{XeOqFhHq!;CxsIgFX}8^<;_mjnWd`;UyvS?xONM(7zDE1AvSn+R@VcD1a;SM z@hsZjPJI3XoDD+x_FZyF6fZ5Yy$M4nlfPLj8;avGXrxWV z2tIK?&U?2^)2RwAXZ6w}TyiUEEQRRK0{Glma_$*Ddw()d&-AkB88uyZ9*#jb_i1aY zO;CW?R%T^(aT`xd)!nK7#8diba(ZgYkgPQtD4zVlrbk3>0<@!PXeQpwfWM1*-Fo*wx>Zd-G4`$r-eQA+hD6TY6i(*J_*dSg@us&TiMePLHeqD}%|5g*k6 zecTnQNF)|262bYZZke70Oe#a+(1Q`o9hpAN|GsHFaQq#;>f`6$+rRU61osEdeao-h zx$z!x*~(+@c;`Fc`4ujew!zAc{_YF^dGW&^qukfhyWf7sai37RS6tS<{Lm9Wr_0N% zzhCEak~Nj;P1e;ozxYdkHkN;O?}{uQKg+v?i~gW3Oxt?B8R4I%*8(;yEIz#Q7nx6Twf843UgT{!t@o%Xq6SebAcf3}T%Plw=iOP=iBpOUQ zc9#_xb`-k1L!r(UCXnx!LMu?HF&1ZJl_=C0b;tAy$kW1WVnI95>N%PAJ{ieDx< zF-O5SwSnEbt4=*=^dIoMNz6HNuI!(jrM`Bdr(K=uSk#h>*^=|_zK?4AC$)nLj15dp z@=YJ^Fz``)iw{wjbybhl2WXBfUhj|Gge{eO0^|lM*mUw;1JOr5^WjC`fBY5D3O$<~ z{lfJ-Keguaj~+8U$sZHDjXi1Ata(IjTvbl2xaw{e#PL$@uVK1piLKIvZ3+z z(B}4nY>0p78$+iPcNJphgd4d7=BkRYD1` z=9|^!ksL*=l5TmKlrC1AO9R&t!vFRgf=Oiznp&P)mzlM*?pD2ArfvMiwPZ-XYZETa4lS2<(CAkpX6{s2OIh0zM5=d;b5QcT=Dc3 z-+%OD&v^B_VpNWB72pDHtPc53&Cq@#b#(gC@x-w5kdBW2^Z)Z`@x9AAsa?5sW{tO-lN~9VW=%BdMP=vDh!j_YY}Zz{2r)5D zmT-WYvS}OJuRA(ndwYJ*Yfx5|KfDUFMrmaVNjI$LZ~fo`XR_7v$G-EMnxwH)`1SF` zzLbyoMr*{>EXP7Uzc;uE0tu|8p55UgwB=HGH9HD$dy$FvMIt?RFXoFk!QW!kkBNy% z(kwXBVljuQBK-MGvt+|IoMY2d*&@<0rBmn%fQ+gk#_9GV-*Df^Bv9Zh^v-71)ce#B zAg}|_@BQ|RPg-^1r_e$FOG6%syAOd#o(bnlzn%Ms*N^T5K)C4G1*{C^7B`Fk!pJ zDv{Eobh6FbLgiZF7%V$E)h}w;?pN&W=Evs|L}2o&=NvFTM#r6(=p9E-(m*tY#TfUV zcaEP?^P>`n`NS2s2frH69=iF*sGy;>VpewMr~5j!HvU91wC5}~&ghAk2wf*X*%~ZT zg^mgBl=2F6hc{z5k8LKfiM0|lwe;dFNsE5H+_!Ke2NQ2@6TO7oHkOG8gs(Lzu`m`K`WffFe+#Oa{n_i+ zNxcWiJkaJ%v#(5s;Btl=OzI!mzu`MPcygZE%dW?h=4hqa!o5rxU%$Df!~4RWET48L z5`4<$m>UhFQlz&hW_s0`_H><_hi%RljA}Z%Afi+o32dRz5Al=yTE*M z>~k);cFZ|MCbkEMNaG^5sFi*7_#5nd>F^Tzg>Tw>>*rl`5D>ktnMe-5S#mfGXyyXF z`DsCmN}{BcN{Vbdcrkc)pnVnZ!g{=0q7XjxNvTZd5;}Dt_v`ZpKP{fdCgBa5-_nwO zx+R^`KogPFuNuT zQjIW$TQIU#!v7U%p9O7~N-?WdDlS&oXyna4;MG_9XsP(4$iU77;X|^UqEUorj9ay( zI-rP#%?UK!#>eixKCsBz=(E<39X@*FG-}MwpMLFkSAXsLT?orp?cDT%M{f9#E;lay z)yF@+@n&7#@$D<{2i?Ub9!wTz!{5kuloqkHA`RJS?Go}tKx>NbGLMc~Yo*1Z8FMbb?BSn&9@rI#U2BA=1tE#W zfGIqSrj7Zz+e-D_-Fzp=rg{2m@)I)AB*D+!c$QOt1Z_D$uJ$mW#tS?8rSCrQ`RE3D z(Z2H12XDQ5^r2m-IzqmDXFWi&f<@1=WIJdwQaKBp`6k~F64>_ zgln^Ob5_M+FLMnT&zyKxKm3EWCCPY7Q-NvfSyd_~OyZo4e#-pU&?6GnIBk5)^sc(pExfbZhd^dfyyzlEV?u^ zriyK7D`68qNdauU5>I&+-|9MlDV;w*un{D^cz@#WwHA%SU+KKApq@@;h*kX^-Ld5E zgD2z1Si5`8OK)S9?)OE*r`TM77js=@yh^XqpI>vyt>1j?x?A8bAH4CFzxvnK3n_j5 z?_N3aI~QKcq95hy+w|1rWaB-UobmPklUt0tbBfh@eaa6@m;2}hn0U#YhTTnY9aZ8mHlL4SUx&XE|Pv;2=O zjBwn>Lo9f&bYU8U6-+5p2DN1lVhkfG zgK8*S;MHk*Z;gfi?Or?G+$lxdx18vIS&Uq&%C8&Nv+chA~Cm5VKD9jxyT zHdaRg-3T8J5fDIYA$U^F902rChpb9jPC zjY@4R00T63ZX>u;>ke51hg{NpVDr^pYWXva``@7pK-pAm=~;*#HKWje!wo z2l2etvYi>~6@xVxg-_(aWM+v&$Oao@5_2q!rhq+Sk<=b(0!V<^ac}wVz=&>wR}_7= ziIN(EY=$qSW6W~udU7*d2V1~bYFPsw$2Lv#19bz*Pr0Y%z%h=-FsG z8F7S?@A$gckTYmi4A_JMD|Nq(MjK=U8GbdRMbSV@EiwjxG&ctg3>D9@s+&}5mq4qKxyZ6}`EgSuWe*y4o~>{EyR_s6 zZp^wv7Y4?h!<$74j-5HcnW`dg)2Vn)(4?2De*m2Fi?P`8QW$aMR`v{p) z-`LnG^))lC)jV?;UFqogU---)KL0CUKL#W9%4fde8(;rJ)Ju4EI(ot5AN+&+f8`S> ztY3KLZK$q?Nnw5Wqs>K&7H!4oYAHyHWt}R+P-Gdw+*xIM^hDEW@1!gymjzg$u6xQr zMWz_LLvZG?MjFbl#edhhdO$0ZGRatVPWj&}vPX=!V>bqyR9*2gwhmdze|-Bj&c{&6 z|MIq->_zYvYczwWMelX~RL2QjctJ^kV(JmOBX>YS$j!^mXXs)G(UQyd@szi*!fekU z`}{4=C1IgE8|l`eWYGdTmHa1v^G17xK2YI7kYcnm!j7mPx!oM2|M`#qXvHgUy!RHI zr&FC9no)pZD2sm+1cukgl*=B&^1YllgksNbqF&)DgoZEnz4_GTmtFg|1>bbNDQ@Tu z&Y3W5EAM;bi@4qtHszP<%c4GExJGY(pylDluOl5L0^-ak%u5(S8i`!;j zF)-xcdJX$Narus0fS7X*D?SX@8?HVWoigj<8uG*IFIpw};~dl*U1~aX}iziQJj&4zuc4DsacELLhUg7=P()(L@FV5%v|D{-O->*F(ERhA8 zbY;(o@2<&|Rc1zfgO|`Ub5^KPRCbNYiigpMjVk7B*8}NGwDr}wKLcFk9U{!j2XgDv z(bc#2zxt-1zTwvC(dYf{H!l9vXYQ4Y=cfDK`&S45{jfysYhU&_Quhz>4UPUlLU+-W zo*FNSw9FL(vHM1tetpx-&@d^Mk3dE2;kp`!G*IPy8}9Xlc_RlhmvniW|9RkYDXExj zumrkIYzqpn0_+MNwr3Y2ouXk>_wI7x^2LKaYbV23(QaEjq8bUT$xg@3gWVk(>m1$r z^KBWX(=elKMV?9~_8&_g7G!F$1SiM@EaFi8>QN;>2yNDcIF8VXiI_9QjXCWCAMmp9 zy$g|sUj*j0s~D8^NC2b_QGkG{1s9tNjIw+^HPu+m$X#53<|KjJyBe=e*>zf-$LY*2 z2)UfAftvvC19v+^b_xH>eN8xwo9E|c6^7!NLRLLXKIarpR<)y7v~A1#oGTl7`(pN1 z%;j^Y(zUO2oDFbd~sUxuGRhG(q7CxS`SMNVAq*oF#=D`V*+aAmNF)p+Q8KBbq+p ztFe7=beQZZCk+`{{p7qX=GFmxrGbS9bGoN7J5`PJ&Tbzxbv)x7(WyMw@Z*xpn!<^9 zNq?wT(RO_nGCCpTUNHP<`?ns~US>L82nDwbO2GpfPMDOt2)_2$E^7B)AG)bN+5B}e z<~FLm3TY~ReQKfD*wO@05s5sY5ICP&pWnc^_P{%tG)ex^i~e>i1Y|!ax6Eso=)3a1 zYMc7X^9gmu@PBzEd^aPA++N$r-dT|o3zq8yXc&vQWF_z;ZWvABo@Y*LKdizP9dJ^X z1uBGzsdK~UwBn+6izxle+g31YUa5gD3Kbr2ne(>u{uMql)xY1%>(9IEQ)XHik!zh>jZ{R3hZd6 zJ}T?$y8=dl%d}Y~u|SwrBp|4$Mr$F$T$Wxb#vI7OEyel@3W^lbY=O-1n$F)+pmGRp zp6m*dFGbatqUAdQ_NBo2QXi$@62`)6sPC*qVdyMAMfNCl_6&rwuGf~*xN$;PYUTJ) z@HGJpo8S5}zeMA+Y=4zhG@S<#H^1$lO3M><7so9`jogUWDon zO9p3F_komENo}L9%qbvjn;e{&)yXOglM)r?2TXd235!hC&Jo4wN}$1o?hOvGc62OK z01{rijkU-N`2X0!OISb6w((TSzaeZf&CdQ!CeYL^J^}Myk$%LN6!m|$Y};=2xosdU zqB+4r%yiB5K!zZRlE}^Eo-`&E*)-XZ%Gd7D+(Zu7nlo{lLrfZ7JJ>O&KIE+;{1n;F;<+7WDs1}>B z74ut}YQ4+4IjDt8c$k7(rS~-2%*!sVL;K=Xm;C`tyBc33tO;L>mcA45z>f7049~W- z#`4ai87uxqx*zz_`KM@+TD5qCH9twlm9JE~BC5wiEgSRKDUYZ(GS>Dj#3Nd$0L-{4 z&647Q3r|AG%Wo=8%sR6xL=c1#%AhorlpP~Z)W!K{FHZMYbzz_s?G`b5z*Nl%_$%e` zMWgT4=xAhrb{y@LO<|&_bh@$gDe-2}^b_@F$rh6;;ky?hI-Rv?%B`WpgsjuFMaEvu zG7`pQ{G}61B>PJz)-Rn{^5y-~i4~k!g-^+ZYzobTg`dH1D9O0 zu$(UOpFHx&mq%Zu%T?*`-_?HAt8{tP7i-&paK_tp`R9+zEpr=o1uNI#@95|MeAlK8 zhy9pklW$(T_qP^)WU-2#*?jYgAO89gx?Hkt&*PuG?+%Pu51JZAHZu&}A0Hcr_7eB7Ti~4Avn4iYi`k#t*8L&$r=@VL)nJvlU<~33geksXr zWCaGdqhB-l<#Nm~mt%gp95Z`429}9bLYd=?=Vaq}U>-B1(N(g9bV`n_7@5^Y<}tZ( z+!lnuOc6s@w<3xvq*^9T@j}j(;x0IxDJa*H%L(LfiY*{B!+N!QLF+@EV0u0_XA`P= z(T=}}=q=`yOI1`nV=sso$KlcL>5$EcK=AO;BJPpV{(kRTIjtX(8OrA-IuWY28`P}H ziv^&${Sh)AvFHkiHN8I27->)=i}c)$mg3p+XLq}zu`COFa58jX;ngyY<#^62;oAf8 z1IX-`>ltC%yIPsicmk?~Ph$j{xnC_j#+T3SG3GNLvg{og&erep7OUA{(YMS^SoR6i zrS2GKEmK&0GTEl3(D(@Cj=_(s8H2y^;hOoeAv2B@z~PrSH{0$FQ7M{$3~v?#R!7lT zJIddxZNLytzL$83m2K>5+~s*w>60cVj#h+T)xFB1v&^WL@6{@5I)`zR-|$SXQq_I$ zX@vaXn5}Y06GVQuBWnjgld2;4am?MjyQJ$b?YgUU-Br8pYF&5ruDiajyZ)}bfv&qo z*WF;(-B8!vg08!T;SM6#!A`*IhGzm*ISC%#mu}#3>Mno*ukh{yn-4tmWQFSpbY%!S zNI7H(NOC56AVu!Z1IgccAo)8FB!B0D!2N0z9ZuypboZ|N zie#`8xon!9EuY?A^XVyKmm?`RQxPO#5eUV2b-o@0W6lx}B_KdX3XSwsljfP5W;#nR zi_T{5);8xq!9}_E-xR*+s@91TYVD`~(b+V&z!&>&>Df~MEcEJZI&SI3pN4uZ(fiX- zujT%J8tQEdmQO>ycK+SdQ19}mslSIj9rZ%^F~K-3BwfBv=S@B%u!A<naPi=^=1y z7!IR`&sW1*vNV3IP!*cp?}YU;)%L*%oHOK22q<9)_9uB~!9ZT{zGsoNPEHJE$; zpCxtc`5J!m3rY868U5ia92N#YiB=^U@9lmSKR3J`2E)ZTs2Jv@|$#)RmH zLKisaCP$zX;_Mba(!5E?R?Zn6ys}hoX}*D_Z-V(a;fK@);+|VbXv^^7K^8)h=6!Oh zr};wFD0c`;*T=1Fvnxo?>v=!Vk#%-QP@L}g<~Y0vHFzIUZ;WVFvMP`BJ679h7DYv-$UAx zu5R0hPQ`W7Psc1I`SD{5o<}fy@kiI?d-tOJq;nmkEF}z430#u=Fr9U!<_~Ez_baW0 z9&yp<&hzB?DkzelLl<3QROP3|A*+(n{TCV8e~~qF7E!BANP1Ro-%Zp*@(Y-FN&axe zBAe9l#;0Ts2%60s1m?D_o@-PFTh2xV_eZOuQLGMrPLUaUA#~2Bx);Q%i)q!o<10e3 zYvV?6X1>tuC^rAFID1rbX6MQ2uFwgY)xSOFWHj*dgLgqKW6z4Am>qzPTK9IIyvaRz zr1NCLJ^5dqC+BM{Hzthb=ZQLUHkTak1`M+iB!&$!jF^!QYqta>!%;)Yh_05inN&G(!s< zFOI6z8&0)m02^pe71+&scXPVkKnKv2{y7C(B;GUzQOWS5ay!f?6trc@)=2NAT#X@DvI^X+K8Cd@^|s~@oUN)lL6Erxrs+MQ0SZt=qvs$@ zecUvBfgLS8lpY&idF&rjC!7&L=tI~vH}FP-^CsSGmN3cV%Q*ge zWG^^vR}u5te5l!I<9T_zq8&YE%%O&_N=|F{vsv#1;LC>2fizT$h>Z2x?w^y9+Y0dO zfnoH7j9LaVGyBdaBa1_DyAC>qK?We?AvMJ+BoR)a_0%C(!EllXoNQ&f4zlpIx>Du* zSApw#R2|)}>fvq%`4W#UqaR1I)Ng@XAV>T4Xhw9D<`*em;UdoMY8PCK_GnZbg0pIN5LKjraImoI>uf7vrormz}`&CR7;=5o()+#^4Y9eXgA#NmK@i9cJ z7X*?ps|0G_i$OgmVNVyI83gn?9m`lLFS$`-Ch8fs8yK!t3hwmAitz?g5Cc}AcEN;= zl{CRTRxUj>1DXQ)YajtEO>MU~E~9&nJX4&V?j0n7M~^XwQ3|Jrse}*%0NqF{Hn3T6 z@<`KYkH`m!;Mf7j<9IHIzE$W?wqZ{1x5vz_1bsK(&1+_EP1h4~z8gnYUQ>EF;O@Yw zX>A92>$XqMtjbw*D^s3go~#GZSou1V%zq$*ULSxm_d))Q4LC6JXPiwTMxc)jd%7Ct zYggQAqkd3u1P_6p47nC;(aPAl~kAs<2aNO3M)&DH- zu(VPK3`nYy>p0b%`3G&G{R<36bY*gyMIH0>EVXw5DP7p;nr+>bN}nWtJ@Lu#iH>K& z8OP)jx`iF+S+dEl57Bk%t`F69Wz$)6cS`jli7Wdr(LF0>V8p7yqC&RqrzWgJ#4Uvi zIHv*5m{>F5%nr8R6p-z|!-GW|kQpE<&Cyv%W8&_o+mvtskl1xFJKXq|O>o1G{uwT& z4L#5AwCR^ffx1t$xR`i^rjF`6%$WZ430bAt{CT)#L$?1R719-+z64*1!Y2bLhh7>*%gp*ucE``& zCDi-AR`R<_I0uy0bATrm-L)tbgNVTnX)w`M3~4qKS5@JvTE^8p=m~oJzZ-ghgE1?o z(G()a!8!BdF=GUdbPo|X0CIks&zhN$~2;;_SHysrx*_jO^!oF=OD zml#P7JwS|j1R9k-5qvz@g@*^b@Sw{4guv3W8DZ4lB`cBqGsp^B=%IDZ!_md~ygZw! z?uc)DwQ0^)6U|!cuy8KSU*;)mtHzaO8ptNFB7g-w!s$41^G0c3-q#ymqfcBIOkga6 z=HL1#;ICc&%q;oLYaeH0WK3)Qq68+V85NPHC|dVR0&eU zf>bvox^0iyue)rInXd&as_e2opd4$#Py?)`>=*bf{xCTpGR zn^)(D;b=OiUB~MJ@z&8mC?(Yj4;}^9>z~u*$>Ss9HMAjtM)WVf7^pGBzsGOIe=qnQ zPx3&`RY0SCCU|bRHm3uyMO)0$<2b^+>1HU^Gc*~hER|_l0q}PoU7*a34wt2;7wYMj zv)eXjO3%rR9&BNrnosbMcD=xt^gPr*a#;UV|D$QF7+SNcLo<&Z^M;9QJM8e zCSX`shwC5terXxBC8AHGfE!o)Zn7Y#FWPQzt9M%FsX6|H(_{o8a~>gPRv$%?_e^SN zLf@V4#Jn!`O20?b^(|+U%E^=#iqJBT4{ysirGbh0U}gXYkq%^H)VRisDCJc1(}jll z43H!NBwT<~50b+zU6>z)v7d_OA%8Umon2%gH|I|Wgs>d?;OVjM>5+%s^k^dS2)UxW z=&|&;Lyz{5I_Vpj5l<6h-68gjV7=X}p8@W~JkrWIhL4z`+LSuI-RD^((9-B_N(X)_ zmvxy@Ld}|aVv_iDS>=XFqA?t2d=jSa{qj_Ur(8p^bS|)AyJi3%p&U=rXsg05&S)_$EK@hN5rXga?5V!(}H0x6QV9Qgm6tyqM{vFfjIX zQrH_@5%gcuK$X%3DH@)mif7t8VC*=uu%VvuA1eT`S!MBtN*SK?UwkD4A>tnD$K$+HSPl&<}VaZ4W)78%L8$}Jj+-%GXdsinj1IS zl>Osa;L!Sy+tMjwSQpBqesNOLD5$(^;55tvt?#a8eGNEm+bgEyIp!E0QJ)tG45|)X2PoMYEj04td~UvJSX)7Hr`{Zr#T5 z3s{p|ERV%vOn)&>L{{Xsu_NuD-k49``ZmHT7@wT?(O7;3BcQ1gbIPOD(d6Gz%9z(B z2hDuHDp?mME<92+zRAS4SecQ$Vs+N*d5Mu7XPGVZa88!$dhc0kF|y7;o&-zn*$<<( zu36|K!K`y+_bxLV&PSbZ7FG*6XPlLD4}+oBht^@rxN%k-8Zwk)ZXPniF4QD6>1!uKKruYX&b0C~`{=v@2S$|FjdtjV({$c(?;nZ{1ha2%= z7iaas4>LKdd)&oYJ0fRO!Bj^?G|$mLDEl*mG~&mYI~+1yVfg44kS+s>E18jAEw!H6Ev?92 zQ(%xG0YZ@_)*%tz$@Qk8SS5NTiLuIJHlHr_xfib|I9L(89r8aNNOn}{*^1?Se4(?{ zXT1LBM2q%_LNgF8L&06@G$T(Fo9Xi!5A$*TpOazdkf=zA|C+P(=>r+#FBED$%m43{ zc#*|lo^PBg*(?a0>)fhuiciD`n|lUfYSQ83`Nf*BQaN$ZT09@;`{|<{u|39->cbM1 zFICA)r6S{|#3|8EG*1VOP3dY#-#v#jD)<@EQIM(B(0--1Q81MiCuccIr77Sr7{1De z!h@#n2KYyBxrudSyY>28i%cJ1q#mHrjA%7R(cCRto5I;PsE*7wBxp|+HalJ}4F^!m-lemzbI_5{#*_8>XTx~DH4}<_Q&LQL zd~RVuArgZlmgml+g9z-Qb>J_d#2MzqteQYY17LFfEE#_Nb_(i2AT~RJV1%{i^R& zv(Sx!%$hOBGoM1;2y{|$NgIV(J*C=@Is5(tJ%}2foTaAi>85a_df%b}8}fqlioE71 zJ_svyuzJcc5(pY4tcTCnPX=vh`K6vVuP*wFG_#po__5>0E)IqVzY+7z)S3w;nJA&UqA`1Al86&a7lrG@d_*ml$&9Al-Oqg^<}j^!0-{Or~O zck^<)(V;%^7~UYA&}EU1r?nQT?5UjB#g7b2evWRTF)2FapmYRs@5>j6(+{G2um@2U za2fNsZ;ZoDbiu~ONC#@w3^-?o$ zqqd^k+`Y9noHuQmaES@J)>2n6=a}9lbRupIXM?R}wmhn?WlK)vX%gtq{hB?8OFY$>OZX=3}4F7qQD9?Q5aMv5EFjdYntx=bToM4c#I8tHP4 zG}cI|S|eRj(-O9k6|e!1eCcRt z7|2?)oR2fsUcoFtdmes?sdXzT)Lxz)#GT0Zj-zD5|Leb8Bp4Zd=tqrrY*WaVGjkN7 zx-?rZ+U{>H!HI#$TZXdJpDh~$iOa^ooV>@&=_fYEGK8W|e^{oI>-cV*lk57k72|p^ zYy`>dT8=jAs@3M8m8x4yrPiEp1@*lj!Wz#G9&Zg>bJc7(wAC-z^aD~FWYE8(u|v+w zXxge>Io@8H)qIz;l!mR_t{&($?Nn8BwJ0UHx;^Z=T`RiH19h8E==N-IXwTo128VUl ze1;5=ad=2BVOZ9y;vNs$Fte$+$G1XptT_g~RBI4R{jM#I9$+qM^$+5n=~TH?;XF`} z!A%FF2qmo*^nE%12e<%Br~@1p4bc%{wYaAvqDFrodXOzwAC~*AV-AY_AbRjT!Q3p}XGE2ek&}iM!kkvb1bH8{;zs{4fF%a*i&f7Cvmt9PJSN>T|JQf_XC4?Qw zyVjpA5hc26IW;mHlGW3n4LEa>ORWiDFLIbsd-zED0>9=i-AsIx+ft6iz_^jWPJvxR z2mx$jMKur$RZKN@<~CmcB=)>&zE$#jwql+rlYvAMGEKS-c7b-O9^QM?n%QxD%NJ%J zchv&^Vhl7Y$%?J6y6a1@J|qh*JVUlX%#OnU&EA{9TT)#2{kOaC`re)40i$79B%OM~ z7P3S{Vo4BNcBUsX5|$jxiQ+hklPHOtI0Ggggs~heVt`@a_kG{@9R?U+fMMT;eTQM+ zVZ;t%$@h1v`u4qVW)LV!KKXq9fAJZ;y4}@ht5c^=ojO&;W=6;K&G^as{Fy(W3B;`U zo6&C01s_5Q4EtG%f4wml0_OAb0%q!f{cC>k=Lhl6_qCCA*MhZwPBCZ-qkM2p=;J8{ zg`Z-;b8_FbO%30XkAIb83?wX_8L)I?m8?25fN76!aCZT)fLR?4088tM=np~HWCxyT z(|2i#u)gm!jSb-P@yscgE~TM1%4hQ-Ezf2%1Wlqp-bB3MCc~av#=DKavo78TE9`%R zs&HfiA9#Ki*U-(=kqMce0CkhNV}a5J*3qn59ARWzX{S0Z1hJdQ)UY*l16drYYh&Uv z1@-;l@kIRw;hWy z29w(@-)P8DBkxIGTDN?dpX!uvAWZsSc|X6W^LIIaSK}{wh*Jiz*-XRv^G$p+Fi(Uv zXrMJ!Y);OI8N2RDtRX+Dm<`MBB&k7vUH@4Rj=eum|9m6Mi{|>j@ta?4wL9J3*m!^1 z%(Z5%z0SJpObm%tP!Mi%KF=})- zW9a0M!VO&2Cl?pn?o%sluzP>2mq#C@b$K8HeFFsBEmuQ#G$^f38J%T?)w8Fxu|++C z4}P~n;t56k;5@#RB+CoEuiy`2QUI*(tsG+gD~mvNzD6)H5hnVcn;X{IEw z))0rbmN<0uGfTfjdoAalT}nExgsVmwbZW#G?i!)mtgw3IXnt-pIbA^`A2Wg^B;Nx* zIaAvYyT+gOVEytB8&X(^nU6QB&Hs{X|BK>axCOuTDO*rpZItTjo;IL+r-n%$2*NQ5 zyRM}ksdDFA^lr(@t9ax1hMT50fSY>vh4{GX-;zkdb;(}DdP)VziDdj4(F534qg~{U zCSE0?$gK}poiMXdv(xi=Q`k&&a?LQa|7DC;)Zv+MEXtnyTy=!;iEw2lw6RT2GLt0J0?_X&wc*JYw5bfy%_iWOTQ z!@|eQec=i$Afg#`gZW)GoU1%~C(pg(v%6?OzE}zWml%-AwJH-574Tatw!sWp4*dS8 zHJ`IV1ALAl=VP>{|2emBZXrI0g+MhYcm{%|yE>83-&h5qXvs<~9iqHKBB7Te;aOP5 zQf6j82bpaZ^*ouJS=(&2l?o-9AM>L#z= z+LE34IKzNZkiHr@kn%9q1-<~Y-az2%@{GgT@H(x@D|x2nZQi!bW;v~B-ZpOFb#P^$ zF^@4IRFd(&GSfy{G8%sb49~7*z_Tl^1owF-L z{!(1JKhxuj{qYYdULPf!mF;hHwTEUAH2muL!q6s$esjEBA~c%(G|E%XidNK}ZaD8r z&J5op-}OH~UNh)~HSvM4;GdVu&Wy0o+z}h%N(pM=Tz}9dH3h*+$FXo`iH6Jq7qepo z8Yh~-F>b+jOG5Wk!of`F-}c8GVL8Q~K7HAC(O5!Xx4b$s?pFR=m65~$Kn}8MkrJAv zS6<_7=6zcGk2Lz_vk4aRA>=OuZc%KXSxr?rh9 zX*#Fqt(0kO8x6zCH2ooJxm8qv=_r7=-OTc{GM{UepYx@jp&@m_1xcP5-fnqqlBYU7 zN%8Qz1#;of4=30D<7pi=Hd13tyOf|AX8COT52k&#;>lHh)~ZzAM-4{&Eufe(#}%H0 z3TvB^(lq2e!boSH7DzM;t#x=UDT+ZsH^rmZNNt3qX%|{WbH#3XLnMCg!yVMH>9@egh9SRyrM}x>+?!k*iqwH8XVKO^@|k=7MA>W&(rpkv z5i`+ap7U$SYMnGtYeaYKy!G9!{PhFRHfPJ5dv&o(4L^=&579%Bb!`x%Ssz$)Y&lZ< zB?eVA%~)6ezaDq6qMZX@?zl&yFNaIjF&ONxGtLF7Gx5xk5y+VFXEq(p*QJ9VF}YwNn5Qm?0!I=UZKG)s{y zMk-qeL*)TQ!EiV_yfB{b1W@V`F!HT7^i@bD92qI|u|>+Sd6w*78 zTuh&gm}J@D8439iU10Paql>_~B_*Rqu;!;k@ON%HBZ7`tV*g8H9=X+Q*+R9}R*!(Y zx%OFg(j*K8=*FZ=Ti~S9O7XT_TU*vxYtKv(cs>`S882`5K47!F4^;B>uh+HDB6(!x zIT(^78DM@Ze6v4eq^};oZybAgsL3}rY13)SB zBX7pm``8|LWYyyw2+rf5M{7-{#SiGRzV%ND43&<;&R+tM*yAd?@QXtLd(jJ%+p%Wt zfy|67`@rOrxPpNm*47~XMSm%MGFO(GpP9H+hD2>N8+GMRikEO5rUz^gb&Q_qPap4u zDk)4ultokh8#eBH6-rPzCVfC7&0xBA7eq**2s?`8MPpJv>>xqv>@Im z*QWm3A7?=->oLiRCV9Y9!gHKlSNpNnEthAkAtmDw>0AdD)sI#8 zY@NBbwp)9IG86fLTO?};*H1K-&WpFs{x7+w&8>s^*iQB22FRDe=ru)DGF6O7ih&$-Jiuhg9nuo+RFWPn4oym1jp0(5@ID&ve;1#oLM`r!!w_JnQ_Vqs=e@kv- z6v5gugzH3YP#3tVqM1(et#9PFY#hfg?+HJsdxEbifBK%#{`K~RI3ywyRGf~W#;A2b zitQDCX}4hLTA^FmO1lL!pVTd6?>%5S+%3$z#jI6z3&&$0-z^Y38oEwwJNoP9xEIk8 zs9SbcrN%5hN{we#YP_OC`pU2ra=IG#=BjaBQZz7{+@g8H&>6p%yl+FzTT znd-A$RlA$9fND8m#42y^8q(DlscoB~7Mh z`DA&Pd)U-Pr!-TGGc!bqV#yOH@lDeyzN4YnaA?!yDa2v3zcNpPXUS#`3~8UOw;yXc zR|03mvX03+^0C2W_hoE*ZftqHy6CxN&?Hr0(4(+40Q=D-9kK1P1h;#7w*KTS_10NL zuG|`8lPR;ljhN>`EjSRV(W<# zan(^Dxis|=&Go;PG%I2A5T!;(HU}w8EHum`SRIe*S2MLp?JzC^tvPNuRtu;)*~lc7cCTe;HWm_K`2;$4J*dH z72vkp<%uihsmpQgm3Kx-b6CD|jHrThu9PXQZgOe?-GoFp{Zbf-KP>IW<3qeR8?GSf z03xJb^+7fLi@p^a7-`@2QlO8bN0*3Aa|FXsTq!OQ8Q{wiNuBWsvlzoMM{r5JLBm8I-i2=`--dAk3t}af>Ngs>L)Yck5 zJ?G$gS1`ErV-+_cl##)JPhZFg(9-$_Tl1F+gR}rNmhDkmgG2~aP-_&*u-FLsr%#}x zdOO*$T#mn1=?zGmv+ABs6D(xvz6LfyL5-A@80+!iYsBxUpKq=Od7U1Jgn`7>Na=I1 z^Clj0QbAYk0dyToF$KERA1a-iud$2R_m&9zBo{V$ZJm%rK8nl+r&3S_x^Rrgcg;Ti zDg9G&QXp7@RnU z-=r$(fmvIBP@kAP!VyN6dp3Q$Lf0$lPDI|}FkljOZ|5D^U8nY>@gx8 z)W2f;K)J2wJ7gRt?wl*eO@cRKT3c$e)D>$-L9NDfIWbOb& z5BH>(&8&6g_=nOJAT4Zmu0?7|9)5i2XZ;(8h#U)#*rZ1KwxI zh((xz#YyyITX~mM>~0+h@F5#~4bENS9r>EDL@wIa64T@~*s$r?YaSDq#q%wfQHhGv zq+qKd)ajd38KX>fT5tmSZrD)740}BbanB?lf>h(JC)Yton7nszblBsvE@PG&g$TOb zTglC)#RdVRA1a`Dn^Y2i$kiNr$I)31zvsIy>OcmqwygFzb5FWXe?dsJ5ZVPX-a8^h zGVXfwAglz@x~PRG0)7UTx*i5Vc4(%?s%(h&B!Z~0efj)7TXP2+xB@s}TZ6S4P$pGaqr97B&z3r*)L@NrDVuH>N!0d$LbS+ansGjFrj$O3dzu=@ zpU*J1_vG8C+Yr?To4~lf&p@&DB`$@(Rimg=FV=iSUZdcHjXJD_iq80m545bKHeH;5 zBa@MKN~SzUoyh}lTA!*?r*WG${<hHptbIThR(;Wns|H}7gfZ?2( zl+NJQ1;ek{R?P)2dUXu1j!CaLC?{n8DJSM|-HTk*2D!vS!Cxrm(7ipz)L;1$7~UB& zYM~UPwcb$*muf-8s%za+)q-Z7Wp>hHyfg{RcwOIKF>3F1-V$R7}`53~64&{rmrwX&EzLz^H4DS9^-b`!( zHee!*@e8s{*P=#i@51J4KN;>=Yv|NS;H*Sw^|_GgeJ!-I5m4pWIV3<%itsqaQ~vBc4> z;3qZAq=s2!38kwEb17!!*pSk#0DFqkt?<5cpYPLAOTC7*` z$&&bF$!Fv!!Yf$Xuv&yMm}TDp4rEbkO4;6YvI)m!yJSTX8Q`C4(A6nb@Goa-a-0?g zY`NQ-?!ZOKo-!=iz1I8`lBM$hFWC{vBHME+4KCM+2iek$?ed&kacDF&yAFLg!#fnZ zS{C0$7j;*WdLGTg9EpgOJ}I_Pr#@vvb;i{hW^gDv<+>ctvQ0dR;fxJAMnJ!G{+`Zb z=tvjPY1~TAHfZ_zqiBncKj1wY7H7GZ;pT8qrTUy}naqAnu@ge}!TUWkz*Igz?gE`V z_LC{j3VRV5D>`w2(WfgqE1jVMSUpglLq}CL2o4)*_*GilV3cU5QKGF;qCMygxG#>i zc2=UWlCQ8#4q&D{LaY0R41S{#6UbstoFo4 z8R(2M&`At*#DH2x7;3CF1H_s!7m0yn<;Ij>uD(SwqW4a1DxfJlWj~FI4v8k3+5l7O z|Ktt8STWoHHT{1xg?`8C^mnugq^5smBr*e^O5#*8esU6fpOi$$x-t?`vkyL!WD~8^ z{_l%Zv*KZO7#61#b)XKkHz5uUYujQXT-iL}Qt6QfnR8cSR){px!SLi-NS;7N^5j|r z-CtQp^@(EY15+Dl9J3X>0oO}cu#iP@J;NuM{0A==SN(fIgdYi4Uykw-EaaN+$@ z%%#^e|6EEe6OW1YI=?bhA-$yb6xqjAX1Wd+)pBJl@85v9glk%X`$Sk)&LVs(5~+Zg z>&DUz)TCqI5OAU&K9)Vqnw;{Z3Ek+P0x3!}0@cPwpK@zGMH{1Jy9GeU0(oB>#lP*E2W>8*`zRjuHV7Qs4PjcT^z*{`{2$BUF=&)R8&~ zwoklA6%~>qd>i>1lUG-07d(A_8XvIY>vlm`OzoUAHF3V38lw z{jsKC9#*e(blTj>)qwAZbg2v2bg7osL#)Y>irHLQmobHoIhZW|A-p-%{h z(8gMQ_;hVNXv-;W?8JM=SXCQyAeRUyWb6zK_qJcHjaU0Mw6UW5lEzS{Lv-HEvg_(` z!;MY@s?kRj!&N}v)I$pErYwY#(#f9*IxBy=q^MBAuk)Z!s^gV+&zwt8R93pYr7kY1 zi;GgxConR}QTt-IlD23hA*7zqj&B$>E^F#+Gz}R(4W_h&eYLD!QQbI^co}<6l%XIG zVT{p-0JKa5A^5F17X?jYNrOQ^!1;r%Wi4VF|Be0Ox|0)9F^b>wlk7Q;SGHUyx3T0< zLhIyon~nKr^z2S1+Kjg!3u=EXb(xnpr}7YfX-MLkhH5>u#=I#eZ?Ky47UcCsI6+r#p2L-yWJDPxW$} zP!eDF2J?n$UN2R{Xa8&Te9?x=W~mV-bh@9}U%G=lIBguU(S6xN&!|!^kQc`xM~M}! z!nuXuR34m&o#NZ^5r(FvIgt>GAz4Ma?)Yc!x(`o;6c^OHZhBWU)E_X^O%oxsQ0&At zyo#A=TRAhV2J%8Ya`J{&RZxJR%q`daE`p|qmrH#XN1xz&#R2_e<+7WIW4QO%8({&- zR5QDZ3p^&L6da#|i&ey2@Y9`@DPb3oIyW3MMTZwR1aVnMAe!Vm9@^+oIs&;(Hq7u5 z$fymCHjd7#xm?s}9?dm2V3#*^s}VlOrZkldw3=h=Q!zPhg{Be%D>T(u)l|LVrh+p$ z*0j=ix%9Tw9K)?NUM{=2YNgHy^($#5Sq3rSU5^OZC)2f6w35$xQMgsK5=-f$tyEy$ zm<$qAk}ZKLO>oNXy^rv`QrYaQ+59fkbZU);5OC@_t+itD)5Z`+V`VZn2|?;Uatb*B zHQEE6odTgs>_Wfx;`Y&PvByO|8(Z!H5k>bQG*`g86{G%?AlfY>+UVI2vh_`jE;&%x z3JeA!@S#2hJJlT6j<%xv*lEpb`tC`%QgWbv4Ex6csaF!T#me@4CAh000eT`6GH-s4 zd3#tqm1U_Ut2_YQh8}&F;f9c7Wpa8$Hgu|rbOttb`aovABr^t9*JG^#Ah2k#g+(}0 zSLN1u76N!8Q8E=}-08=wTcKX}iRn+AqaXwy9ophhw7S_t3Hn>7z=5n@TXN9b0k1I> zxz%LfQ9{ScbVK(ALx#W8No?u{Zno(LHIK5}QKbC=k4&1;az7lb;;|LEqv`y3IhxJ6 z>#^K1rB#s06`!d|9j2@TMwLaMf!DfSyo*5BCu^6Q=8tU`NAoca<6+4@twBDQyvT~Y z{t#h269-er*-u6%2P_ZAcPnC14R%9Ie#4`%V@>VJfE(ZYLRZfhtA@nvL*ZAmtADwe z7fZ~2)IVxUCFWnNY9QvtWIrYSUqM644;B6GA?E%d9P0Yp8zO8KV*X@wPKi+ui}}YZ zh}p3wG55=8@94}cO82^7F5M;ncci=IY|I}lbnmb+Wv{StsM9SZ`(ht@yo!{jTf;#Fg0`XCSSUP9gzZ z7l=ZnqE1{g1B6RQD%vW%REqu)BR}4d2o{52;AAhRjmTt(PwqF5a-k4)NtRY&>qM@$ z3ivn6C7W0#nGd*I#TLi2OCWqnq?f)^dY&ha53$**7>wN=MmpXm$^q05Q?e~>MAEb8 zJ?3QbVxj#>hbP3Q=fZh8n`|J+iW(tVv9`-Sb;t*|XI-V$B;{MR*7;F&eQ8&ke&hp6 zaJY(jY4KFIj+EMT4Gl_}P5MWkDYbq&Z*!a@9-@has72Y8+x{V^Pa?sgANlZ)V($qsw6YoZ5$#wCCYzMTRD!@JL9qd`5@}bv*Zauls0Veqv1^lBVXp+GjJOu?AadSba917V6Itiwl1K)%oE?t!^R*A|V&Mi3> zhNk5_IHwWTV%(}C$7@4EA_u&qolysW5|2qek$sIdO~YwyL1$cj`y{fM55I{JJCl+CL*rGxY*( z)MzC%^v-yJ8tTm;s`Ijx<-v9p=5^&)=IV|KEoyypZh4WK#(&MpH%4Zy@`Oj2|4VMI z^5XdNYkb>+2_0;y(gdYVyrhWMMm(7{mqTqHibVaOrpbnT<_rWDd**@{9RsuPIhjr? z#k9xfasBQr_IyjZn2$Yqjx-d*kb?Bv0?x z@T2wgEaYXw(^~a3{^y&0gb-BOw46FE4in))rVlu@@+!HHI;B;aT%Mct01wtdX6{(( zPUM{JQ}62T~@>R)wOEz9lu1Yl1jO9nKxRkRnO-|zHRoi zqEeTdjPi?BZrhxFZfpD-S&QiH^Sq!@N{-(4%o1*NZ>Y-r$=00Z=WhEmYy9+N0+&8( zeyXu0BM1i~-Et>H&i!hm@w*KTZY-U2%OkekLfcKe;?yeXjLycKkFL7!tAC0M+G50V z50>_Coy=VR$%f+XkqqEzmmSZC@U}k=0cr%GcFdL@0fO&3O0J?rsRkn@XtYm_u#78L zY*ji*l1KSPw)jmfQ~Ub(KQPJ7@!%bpQ95MmS>1_~Z>5%@XcMQXBpW>EuBYzV_wi@W zerTU<$8T(9?bJu`j><2)Q{;V8k&JnhnI9=k^e@KFm3`31Ag?!%906-Xd{Wl52R-m|j!ofntlUV)D6N!FCjD^3+W|KX5RFHCta8wV zxaQgTpC@Y%i&+wlOnz!B(U>Om6&Bg!+D8r6S;!eX*>hDD0pz?(r83=ke56!w=7%_gflVlT#9lDi=IP2IdxhU z7^~_2a~SLX96)Et(CHYdqH=4#sqvf*tvXRrCAl@<@sivcx**Twh-|`Nfn5GP5Gsd+ zXEv8l7(XWDENgeHKay*}SX4c-+)I{VKvqm7Deng2r2|g{GCr24ii#yQX+~s(oCfg5cz`_|bBAAL_o!!HIsUYFKWzMS^nQST z(XS7^yH~L6)K9ny4!mO#tYgOO2k5Z4HIYIq$v4ic&Lm+V9_}E3w?XgA=M+&8H~ca| zD1McfiyKvQ7vq0dH{YstO#T}RB^{Fp+3z&aDm|A^$o~x#E$W7B{fMHeMFxtNjjxRo zMR)?LQZ+TZDbHFy^yjl>kce;-C}I!lq)x9ZhzrEL4EIbx0vfh4XuMBhfNoB4gN%Or(8LKwvS8NA3jisizBQ=rPY4Xr#_M@v?A^KiA>PMr!2} zY%!Y>oiyh!wV4_X!t-NGBxZP!dQ~`}=#oA>~p5SmJDjKnQ!{NK3Xw zA`x_2^i_01Rpr4T8qgTmDQA&xH*VeX_i^8e1#|i@k`Ph)N!?egi`YCtPNi||T+3NmS74v$rl%r2jTXx7%{tiM5Z zFtHw!M(nEMhx~d&X>=v^DvvWq904JAp_GgHf{eFjSrdjAyCO|~myKxJs@&eQgbR;1 zdTN2Oo#-_)|gG)$EhhQ=Rx`)$fC!2n_I;FqpCIEL)+PHQ3vJr`1~e9%!{B821%UG&4_ z@;PVk;blQ^*QUAX+TZnltDOm| zU=1~g`ZQKVLyoUG@sJRM9_IegJ2Vf8=6_Eo@?`4BV3a9A!`*yHSBJVT0kNT9g*tMs zj*Msr9od5$RX3)eNgdRUDS8|NQPJAowvMAB)dUL>(o4jzx@kWC+qENHhkXzVJ}xG~ z0~*pm_g5$0kFq_X7z{OT4`C;Fd$=ljVOXW+BnHX~MrlE%m<^Yb&TQdb6^EaX*b)K}B^WLk$BhTxF@HhcBW)(GsmT zxD`~>C5~hTBZ;U2N>|HR$IhZG#39NL={Z+xr7Pram{C0 ziWXo{37J<44FzVct%gIH&Ut89m-S?^KS@L7V{!_j(rt7q6XI}|qaKxr+8>UAollQ=9 zG`Nf>C5@`^y|sTni7=V*s+l2IdX5-aQFH)EMPa6D)iaUmRy2ux`NKmN^yUl!*CEqp znhnU20R!$j8V>>L(39wg< zKsaEBSDR0~Q9)rBvX9pi1Zy(rE-PQ&OXJ-WY#*B&34(M2?dAMo(ixxIUa<8&JS4ardYK8B45Xn5Wer$N(H291QrO2V~#q$cwsRpbl}Rmm`|sv;}lMXEGM ztKj-d97_8P(dv4xVo|xOo$j@yi=pX$ z6wtU-mmrBox*-PoFwh^B8g|Mv8QlH3q4(98@wQ=2^%SrhiUQ#;2DJ1U$cKr(=Q!#z=HVwFJMH7%^u>uNLnpgCGBET zcMj6Y)pA@6!#pBPVMILyCyy(Gbo0Desnmkz!#YN_=#V$yBM1VCvmIHC@tf=6JZXgA zwnx&ZhV0m`^gG3Km6s6B13lT9p-Y#i3_De_9hh*E7c{J>jx32QTHN+5{qfZ#@?_8% zlo8m(Xmz#{b_os`h)tG!S z)RZZ`#F6J^rF3`z>Lkrd!Ih9v@x-Ws8dkp;y-2cUs^x*}dY+197qttAsl7F;V-q-Z zX;8{%!*Q_%bAAY_1}Ke9!^4tWc53>dgeRkclRxU#xTUhv8kU$hGb}MuX;{MiK=#P6 z#1sbWTMs|hf=s|n8GwK|IslaiXr;6KO1W5nt3}lJ3taN3l~5Lab<|4ZH6DSFIZO-U zm?K$6R~>i96V9k8rxIspLspS84JxW6A4?r^sobSG%MkE2U7yiEVrk(9ob;TdK>ZC~73}#|%A) zHZHEN@>_WptN0v0O4C8i77gNlRFs#75T% z5guRBr?i04@gapA6B*hSKb-6geaaU;CyqOP7(CU*2k)7(k}pyH){1gKE|4w`5baM{ zE%5m*B zu`f7)@^?rxA~+^*2RF$3Kl-liV91s+?Z-rX+?Qd?68ohT|5=%*lgVyDY7td zbU41IiU#pM)B89Nnx+xatI63>HEAGCN425QP+d(952nE#p6T#{RnRe%#3jW{;IXOp4b*USL6e$>t+2{DvYRs1P zT|8XxiuLjqOXF!$uunEHz$GI>*(izEzT|lr3P^qX5oQY2J50mwS zNY?jjvc6Z7^&N_r$Mu9CQIAns2h#qK0>|<}K80N*M5C}k>#=S}wY;JD+}+PPn}6-~ zmg&p+npLwfw&V%kP~_s*w3tH-Ys1F+3M|AOp1I623+4pw#*hT=A&Zt@Z~O)yeQEA* zH}vtB=l;V+W6s1*3+5RAX6-_Dfy@#AhwW*szN4>_2%bOiD>PLhWiMMh7Ffe#AX8Wk z9C$$G1`20yAbe&s~jQzkG-%mdrPP6#;!eCHG)WG#1!Oban!rozfFE#cUv^!aJV2VHWbC zzWLp0Tw%nc*a7w8eszrLMI+0}B3vyd3u)!QU?fo}gS~!@FEws@90lAMHKH?psj;N` zr4f*x$0>jlFKRf8V0|njTp}m8IcIP5YFTVJh32AmOOX%oyb$T0@F6PnE-*ZKvt<(> zdDc@GID+bdaGzqsPH@of9mB3~;6{%LkGKt(EHr(<5;OX%F1`fDh1$ILlfR3^B~yl; z6+sHk@L8QxElFkb2)J^5%QRJ)O6W+Io3)G`{nO6a1EnuM(QgD^A$bVH(Lz-TaJ2lOlU z5Sb6zpf_YBwC3KdR>FToF&WJHL*3^HP3EeWa69v7-ur;+#)_}#i2OgDYhnkr(#FMX zelF(c0{xuWF(&eqtC264GU2L}H>5pyR+3)t0|8D*yKHSbnR95jD_lvGhJ-%Fsp$89 zocPyj2yy!i<@Y6 z1S)h)i^Z~RF{_)*8}&-nt=_64!_GIW7LI?_MV70JsAK6?AODfh*7G;w2%|R}Hs-&m z0fuo*c_{uvpns?F9cycWM_+uYIOPZ`P4?z&3kxO5DRZ))ZX6#{W?7o`jx^D}KwYew zQ2-Q;bfD$SO7E>G|ZJEevgs$faG+4zstb)fhxgb)90&a<9UklTKpJ=Q}su!iV- zXu=~oP11g-fqUTJo2KrFvg-51xDPjaN}r_u#3YhYM`zEbOhIGaNxa*p=G=gA5lgU* zlAcE6e@j9xA6D!5Z>g0`ILdrQ95*#mDVZZB%j#z;#v$Ts5Es=|sU{4=R6sGK-ZRRg z^E~l^Cj3>h2?`zu?nZE zZUmu7-9QbnDI_E3Z}aEl<^0Ron&$D_fwF6zc4<`hmB>O`?85PmqY72WL12~l#PD;2 zThxiDpXCBKpJzOUx=h@iq9-Hn=6pQQK??K0<6Nj@HP==N2UysZiG7ptwX$1{f)Z`* zx_)|Co|RYek=y}ns}eDjc~&@6ZJ2vV2(SELQGsUSm`e-Nw8(4uTnIT4K4w}qaY&?h zl*W~4!af6LqtFt&$rF%&fefN20Mg#T9hl!-Mc@mvSP@jr;gbfw6llkl0@c*O*RmA@ zUpk9^g}@i;k4_E+zND~PQc>UtN06A8e2gmU^nC#Qe|hkWNRCy(FF(g;Di4NPbYFEe_*Lz7Vm*bZ zm4aVWKNR!nQ%#%U#e-dnLgSF?w;!?8{o0Cc=y!^G(eLGOj|RW0v`4g%F`tOm z#0RmD{o|3SSg}5Hg89%CcM;(J#g^8^8RK4k1_E3}iUwsD2#4WPx~$ zKS%HLy|yu58F?u#k|}lo-zACW>bZ)PXaHhwM%q165?!jg?Qdv65fXYydcESOYl1s+VT+2?vo1-a)U2 zE%el*8UDo?F&N?x)ZvE!NG3=LKGJO7CFD;lo6?X)jg%5JQYPtOTEPsao>eq7tC&HB zG^@~dvXo!@6^hAf%w|gjDFVi}bfzN42qfLLnR?2$5TV~@A<~ciVs%RG5Jo2P#=HqoH8@lCVbq_)0<(k702%o6TY5Gxx5vXzqS8yNvrUoUK%9g3=z0GSCh>DG+^I=jI zDpg>}oQUNWfy!|j?CB`xba%4m0uOBi4zHu3(O!)jE#;>|OG7pj2^u@D^{~_UYCuz` zo!Bo9QsexZ*kw>|Ozbu&XI1&-EE^;<9K-gBtnPs#Qv#v6LAQ!|q^AMPj7f%kfi+v% zoU&2wp)MEl^0U-*pOUyg6MT7qj8SquG?A6!2wi`&G4ZU7mwt4EH%OnxMoL}Q*rako zHL-^{;^!fZB?N|te=CngujrlmRudPl$oi2(#%Dg4Z6%A!ysRlk%8#_#^ii?dy4p6@ zC}vATdBO5eTnb@xeB66Mpqkh?o3Xz)jU_YK@Xxm+{ER6fi%D$Cl;Zun{VWe~2kOfV zru%4TWBLB0>Zz40)xz(XZ27WFL*ob^!I|G5#=7kMR9wdxMp$S87psptc4WRM9P$)~ znMP`y(MS_dOw)&RW7}f0h)H9|2Xye#=~y~U$DvuBQ9oh>m}f4o=9ziZwQGasp;aRC9G*sThjX5r9o$r(egV-BVpU9FC^H%084jDFS9_b~V?L~KzmTG8@ zkt5kUb$%9-X=f_N4Wn)av^Yj{%PUboPh80kdHjJ6hJe(==uJXH-{AWP+*TwqqOx%Y zBlaYbA>T+?CwY+ihOd`G0oYP}vdrRUDoNk#>S}ILLWOFtD){3jQF%%jEY@3U$A|`~ zv#$ohJZ28n=jUg&0u1#jnOSU{_V^F&ZD475=obTp@9U6?cqh@8(G=Ag=uOqz5KGnD z7?6SLvh%GE>Tqf6gLX;z>QDw7L%mHu1_M`P{Ol%)@TvWWv{pk{j3!j7AlnqZ$T*$k zciiC0A4Tzb{hR{Q)g9{cN8Z@!K%#k#atWL98`RMGz|xDjZv%ao^t^Rxa@qpr(x3ih zE5edv)`Su+O7&RpFhquWOr1xdtI<-%-IR=`m?|OemZuSew{9aR!eP3?`q^*NWe=-2 zpsr&L-#sb)ZqsaC&^sn0k&*DZlfFi?(xtxT<_ z240Aq|M|l%Elh@BpnsWM)529&ckY_lKW8}1<)Y$v2fl=aHc|#n+DOi`Jb`FM*vj8lj13x}NA=a$r=m+?KY2ejYd3F{9Zz zozC40I-=(w~|E4zwkMg1_j!&@ofX7T?zaK&}&fgCI$j&W${Oj_M8B+NL{>|XuO#b!x zH;sSm^Y1r(FXs4U!})gKFA0Qh;H8RRWkIOYh7Gb$qN|wf5<*l5*VMaSa*PjF@K6zH zw}N$m-t^L<1}VzVtYBD%AbW^JUWiP z2Tq=>skOBZuUy?D6k#0N($k(eOoNkq`(F@;Io%Pf-9B^9terep!+pvXC4dE>@>B`L z2hsLWA#q);2+39xh*cbY9J4ZKqg}q)K;yJGy*0;n`91$ZVpHq)8x8c_@BdZ$N64^8 zq=)40kre|A&&Gir^4gpu%QP~=DBZGOX(W0a^WOMN{$!@#^F1{|lkqCoYdT0+cu8rG zbZ>qQB!83z3FVNDhM(=?Bc-~ zvIRVGYd<}2WOU>v`8GbL2f4*fUlzeQNM$EA49ZV&_0{AN2TGGiB%~nZ5fYXL06c`s zN$0W4Z%}EMl~h_kjVM0K`dAY^T@|Y}`tdvRyjkZm4SA{ZuG8|7#u^P3P#Ae|`gy7x z+gw+3Vq6Aqb(Kh*qiAx+w%imr(y={Nlt_=<+ZzfTwfv<5M|iMHl2NGUgzLaDAGkLA zu;{X3Z+p?@BpJnC93nFi)q^s<$HFFuiW6t#|0&)OJuD^$-aD+#VsAdX>{kI%*d$ZF z^56|yq)aCVCV~@WE+rdPVF;*v=JRAeOr^|4${Ao&4*s{B?iy-yx?`xT@&!cLq# z)a($$t@8!O|BNt!v>W0l$=i^qUF4I#GSJvusp|?;V~5i;O)r!&;;Vl|G-0{A@>3z^ z93?@u#^;k3Qq4PtM%UOYa`h-edP;zg*x3?abuo9AAflQV@<~_oO%bMrd0b_u64XRV z)b;YgkPT4Z=HTFcpoStIR%7B|ko5ftD~zFWpjLou=$l_@+;y^sfUIPE*EBd;75BST5mk*k@CG=6w=|6W?GAbThF zh=SfYSe~Fa4y`#zb<}Hp!J>f-rVa)i6|v&OyYf1+wU||h+HXq-3#9q98drjn=e%1A8`vhlOG5>y6I< zVC@vuUUxXE?MuMklKkK3Bp^O;7g!Z47dRE9QiGLY@#M$oX}Cd5pAZyI_N)plA-`%N zL=&^s=(TE(U5;Trow?c=P$#a@)L?weto<`}zd2gWS#1Zba#j`FKO^V3zyqHotLA4c zs_7lSdO!Oqr$pIKKb;)YNhZv*t@kscKH1MOCi%~P`co>lf1r7a`|k^WswCwfoJlfJ zcl?4s&zAI(?O?%YaYMSK4VCO7i9t{qB+{A6J2e;g0rqRS=t-&oW+*D#~PF&)?^bDJU@VQLBu+NY;D6GZHwUo>2M9mV( zYjYF)+FJ(3KwHO;?9w;us=@|gJyrOut!JOzB7Dx)wa;xHK2N>RqnPDVXT(HZFtac> zOqLeD!0Ru}4eQ(b;Wv0XX}^)E`_1&h7wtFgi<^fHm{WYoHn1=KP53Q7`7LD=JIXH$ z_LVIHmtl}~7XCr{^s9Wck^KYPXzTC~?W^_==Z1e||41zVwryy?JvV#}KwqOF zirFN(eVrd)=a8Lzc0Rk9EkNsqZVEBmv#;a>y$Un3JGte1CX;otE4-(Y~Ed^QRHRyZcYpWDB+Ki@L^JKp{~ z1>Jbq5C1;C`w#Z-!w>C0g#TziwEwtS_)h@;&-S0}KhFz40`ZRqZ2Scu|Ap9K3hr$D zmk8#+MlgSA|JD9-i}2sRSdiHcnJwV#<{dKt@2HT~fPtNq6|r+>J7u;rF+j4k3fqN6<;2FWu6q+4Nk=kI7RAbM~_Q=9sneCZ{y)&b*ceYvBM+EGf**=-=3jzCyfc-pX=2F^U z!1f1Nty%{-ynZ+^!96H5iU(y|go88VM#n=kJ2(r6W=7#qSUgM^4$thc%nk>`5yEi9 z2#ZJJ*oUJsJ2JDQVDV_-Ji2D_n1txq%qSiUi^r+PaW#v_ry3_@c6=62%S#Vew|Q;w_oooY^g~c&l*U zTC;dtLUem(6mN&crK+*CX7P?x2aNGv>=*%O&P35!n&=TkL{PbWmrWJd8BSbSDBo~>DYF4cHGv*)t#LT1lr;l<1- zyab7e@Jh|%s{;1w2#d=dUO)Ui!F??=im$=q>zOUj!W)^ro`p9v zqwppyz9kHAXZBWRZ-e0-VR&bR#doEs?`8IGX79n`FNE_KHH+^jL?2{E@dH@=P&GcR zS^Ox~n4cS4Qn$-(ejc{Zjl%Z%W?_dM0v6=9Lv9Ol>|G84JLUsRx)UK?+X)Y@Ha9!- zNXB#*|2q+O&5h!&`4(Zf+;+~x?z!!jhdpwmut&aW*i#tx%5Bfw_5#D+!mzh63@qwC zIjy*FZu{i6FS`x*6VCm>nJnu53DE($Q9K~uG90KH2T~(h)PquugL6A54~OJ-a2^iL zjl!X@c$f${Jh#JgI~)Rz5CKQjEFLLfM~<*~l*8+XqZ8a?a-(<*EFPQNQF%Bnw`22g zd~Otuhs6_w;l$id$n8WhoFoh_A)HKBAl<(EWVl$EzgbOa#;Mi zYW%!r@wHUr_1s>|!yCE1o`*Mcqwppyz9jWi|-29yCW>V=kWUB z7YXkBxlw!{7C*@Cy*zxF+Xs30C^rfp!Qy-ZI$^uQ<`=ddw-X8oL#?YY}!YY_}rp zfs0qz9>r#1PZ6+JVS5&~7X<7r0``tOq%e&om<#>uz0?3o?o+gK|*vPhOe*-Veul>xTt3F;#6Z{VHX$SlEM}i;Zj_@ z!Y+ly%S6DU!Y(Up5d>T=0xqvvyh6aP7-8{Bhu05_6WpsXe>i!tcy(b{7U7!0t}en7 zOkQD2VDVaExUR5k3%d>s*9*h-BP`xP@HE_5*bRl<2#Yrf=S?+>Hz!25VE78V1r~2r zjazFLZ%Z|9FYLA=EG_KzBHV$CSJ)k}c&7-stFSu@y9)yD76EtHEZ!qv_l&T3ufywy z`x4yyF@HFDu=qe>_ZH#7!X7BXLzuk69)iV(h2fFH9xm(=Fgz*@kB+eTm=twcVUHEI z3>F_3&c|yOpGb(F#PAjNBrHCq8c)?MKAmbjQ`pl*c($--itrpRUSZF{;`1Wlg~FaM z>;(vTQ3SkLv-pyLy)?q&%MPy}UP*9Y#r)yq!Q%45UM|AV3tL`<*D!g7y#|Y~3&R_Q zy5_h9iCs_~1O#rIQ<4+?v~ z2p<;qK@mQ}#Vd?d#Gpi#uwB#UH*LEn_O1y5+k3dr=ZiZimbC*58MV1tz#}#Te#|p!7O*^(}$ARH^VK{z-#S_TY4<|P5gr=Pcizf-^Ni~ZnCq$<-jp8Y=c&cig zTC;dss&RVLPHToUns$0KoY^!AXTsuHBH-+%oz=9nA>bSla8AwQxdL|X2#e=AynZ-8 z!M&hq6fc0q3!8RcGhEcP3!CBMrct;U78eS`B~4q{v`fHnsW4nR!s2D@K?sYQc3IOF z!Q$n@d3nv^6$#OmO`~`vEG|}!#Wjmpr5aZ^?W$(DrfF9^SOSaJih%2yc5TzH zgMjNr!1XnYHwf4bBP`zN@cQAV1o!5qQM?%zZ)w_%&2VeeZfS)k8pV5I@jlhKuV(T7RO5lB-QNrk zHtm6Cc&KR<9)iV(MZhCXd$?(jK)|CS;L)1J#{}%L5f+y@ync8*!F{4>6rX^_C!4mc z8J=p|lg;pS(muNdroG;@Hz43m5%6Zs;#> z)(DGlJG_2)C&7KUX%ydu#rK-_b~F5j16oS~kCB+i|SO_KMMO-x`>k9r!H=Zb8c^E@*8Tc2tcWsgcahPN~MuE!(LTc4^tp zt*~p$DD2wWEbK;tVc5N8yR~fh7WS?M0eg_$mO{IG3fP_it1aqY4zC~fPH^{W8O42C zTZDaEwpT0c*Rp+EVgHs<*uS-DI6xQ=0Ny zR5%ZJNaCw4zMaw8&0gG3*Y*8yL zZrPQsa8=7FTm_3)3&S-nySio9fMJO+EE!?(T2Ar{*R|~0mR$#n*9+(MHH$YSL^rmK z;*GF)lWN>lvv_l=aZAf?ZiQQ0c1tVV)-npW!Q$;AU}?*4Z`o1^xI+ZoQL}ibfZaL5 z;$04}AMQ?Y?`avudtmY2mfh6~_qFWaR=B@q6z+$`2ZZ6lmOaq22f^@=Fg!HE;=>$z z79MHY!!3IR79SPPM{5=zONf@WjN&p_d|WjiuUUK|)p)XHPqe~QEqk&Ro^Bb1r(y9K z5%6rwo@v>$5b&G`c&=vgc>#NVgvA#eUO&8;;J(x{iZ8+9%Po7M6<%rC%dPNg%P71G zi_3-K=Pg^_vY&(DHDP#dgvHmTsBg6F^_IN>i*E|&n>CAXB}8wxjN;p{_>OA4Q?vMP zs_|aS-fe|nwCufBc)w*7-iO5xM8JnF`=DhXLcm8N;G>$w`E7vB=RASh+-%1qIdI$i z--)n8+bHhP-Xbh$+ji}+W7`(A!%l6Zuv2@}urn#eVVAb;+_qiX^TMueFzl+N(z2sp^IqTNS5SilY*Vet@$*AIs#xQDfk;$g6Oc-szX zha=i{csm@~HVQ|=;!(nIblZ+<+tFY+Mi`D6Ve!~D7WKHc9ox3!VDWh2Jicb}goNnC zwoyD07Ee-*lWG=EPBl(x+sW;4YTHg}htt|d;WSu0T?Cxbw$s~o1_Ycb0?w>iJWIgN z8e#Elhu071B)I3cjpDhmcwXDiZin;Rc3wMN&^8Jez~Y6%a8cVXY}-X(xL6o29$|4I z8)(BNZClv3OJMO*;k>kF@v?+yQQIgkg2l^Kn&3Xx zHj0nI;{cv={q9%1nrDeALrd!}vA!s2tn z`CQH7^9j)lZKL=CEWW53FV-x+lxn=(wwK!BmA1Xy4zIS2!mF^jTm<~QZOhyCa|n1% z1iV(W__~0-KEmP~4zC~HOmN?78^yO^@$I&~(GKsl?d^7Ww`~;Og~j)T;TLUtuWi2o z!~4SU{s@a7s1-kK+Xrp?5EefY&W~yq=ac;*2X4ELQQWSxW!Ro4wmnC)C3CYws-6dv$F0PT0F+dv(G-9iy;MXVb8+FznZ{eLJ=v81@&2{e@v*Q4i?A;(;AI zpkoJel-)tXc@Q|0MLjqnI;3M14}rx)RpZc_#lupK!#j3ZCmhkS!#m-~j!`%g7LO7E zM|bR~jvWmF$B2MqY8Hi1~2`6`q!pX3B ziZGnou~RyBDi}@^hSNq^JiUXtIiq8zckB#UJX1K&tXVuOAv(Kb6wijmb5!G;n#FTd zjq^HoZYP}IvGY3Nf{szR02VJ40T*@b!j4@80T+vai)$7a3fRIC7B6vl{cvf5ds)XQ zUIvScI(A7XT;8!oop43RC|m)HR|>=8j$PTY#bCHf7_J&&@#+qJ@tTfZ-LY$6afxs) zsad=>A-b+(6t9ED>s90Wn#CJZjT<|5LnqwSu^T(#=8jRg85VC50k?MSmX6&D0k?^O z+iDhX7qHt$SX}Dx`r(cQ_s)({yb~7h>e$jwxVvL_b;3Ozqi_!_-YX3Eb?n}b-3NyI zh2j1Y79UV6KG?AbI`$weJ|vtE)hs@o5Ixc{ijTnJqpI;}&EjLJ#9s4;fz9yWn)hxcA5WUecif_Q; zo2v0<&Ei|B#@iixs}tVo*xQ}(ZpSFR3ybfGfM0a%y^j3?0^Sz^@7FATAYdPiu=t_F z>xYjL-1%LjIKR6^*sg0IcEa{u+pZgS=o*C`x|@atI%aLht}W==j@@}-r!E+F(iv_8 zbF(u?T!&q{wsY5ZVH@?Xy0Kwb&h|{^W;cGzqVC=`io18W411`?9@Iz{b&Tk0sD)9{Y8MlZW0aAThs#`UOya^;2zvH ziU-5uAzeGL8xHN-A>D9T*C-qYi-!xt5nVgHYe#_LNMSf~gvFycUOOD!wWGRrG%Ow? zoX6BG9-9yy*ENdA!Q%0%aeU3<38}`3T|1#0PU_l;-EeZ(D4Yz7r-*=4yLL*~PKAKe zM8Ih^i>C|N=_4$j;qdz5%mnwWu2DP-7SHb58QpMB*Us*SbGt_2Tv$9$7|!q7d0jgn z3>OH)1tTn8NFr;vsB0H??IKvbSU4}PSzMS9UD7p*m%!qss&Q$};$^AEqOM)m4VQOq zQ8!%CH40b2;*}y`ao4Ww+F}T}N(5Y0vv{?DT|L6$H4d*ImL#~>c8%h-uy|e9uIYyB zyLMeS+|V@&H^AbJ!f;d9ZtU7kV7OTrZXRLr7AfkjUAv`gx5DCW!g*WG;_V61(ymcl z3X6BB#vL__ccvP5b?we>xVvk2b;CVfqi_!_-YWv`>)O3tyAJ~H7XkOzEIuG$4~($* zpu_8jhZ5X}yGHS0SbU^w4|c<&U3;V(9_t!~$6#@pFg)J1WnFt53{MEd6C*4>saAZd zYfpCVDOh}3IG?Urd?q1!wrdohg~jJoZ*`5rTd?@H zFuc>Xx4ZTZ7~U0zcSl%!Pp$ZiuD#c_U%=w~!ufv9;s*)Qhh3xiAuN8R8Xwgx&gbAd zcky~QzZbUe*>=6KL(eGe(Az95=t01aJzLPT9edcj9t7;v8mQtsN^?BekH zVb=tAx1Lelt+z$ky=S}h!X7=_y%+ZE8HGK2n})rFVeg*p)w8|9u#Yh8BMbwJx-W{M7hO*l^ziwJ>3j%c9u!|8%@ zM$b;~*%{P1Q+3Xy&idp=pVgxn&hFV+y>L#?D4YY{bM?h}Jv+B&=YjWp;XS|NY=dxt zUSHU=3wm}T051~2ivYMm*$5Zw$Hju~*f$6Zd&(oeq-P6zb_twbN(E7MSuZ6MFA@uv z_w2HsUEbR|T+y>dJ-Y(9SN7~m-MAhW_l&O=^XMu;zY6G^_)*UQ`ewMgS1xXZYxL$C zsx0Z*lHU6B`Cr4XX7BD_WrLh?ws{5xx0_s@V69ZArIc}9#z4B2E=M7Af%C%^n;~gk zTTHmDjV$^=qPTUeJ8{{qKn^`XjZu4yyEkk+fdbo4vT56X!I1~H@`RNqs3+}emVXZ& zoQcZuB3$8Oo$qon05=X8Iq~zt7&0G2o6Gsv3L#h~76~_fpUDB!vhoyt81TIU+%mpk8mU~`7IO`990 z+w_Rs*a^MiU{}w_@m-y1^JJb`MQsy^NP#2Up`@K4w$&)>fg5T$q*IMDgFn9H%GsLh zNnXnH=4^MGRzA8(8S4I}7$06#prvP#OxJ^@&^Q%jW zf0GRVwrBX;1R4IT+w_UW`b_U9$o1z>lXQRn%m_1V4O`P@OkCw~KSSHiw9nYgd0{Qj znO;lQ&g;(ttY`PnCA+_^?0)d+4=f7px_r7GS^ewHCC8s9eRBLiXP;G$e_J{JeVH_` zX*@6sB&m&q`o>g%z8l7|m3r85N(s7ZL_L zPWoyGk%LBX(!u{??@R#Ws;={|HyX*ZM_A8Twq;wuy;!zoEMo)SFa|s}foeQVPu&HwkEd*3XQM%LJd z(3Hk>H1FNH`#txZ?`$8mQIYR}Sym=NwncWXaE(8N+|(0p^iV4&lgK^{%a-;AEo~Q0 z#g(HtwH_%dP+R&T>j-h#6q1$xt7-x&hC`|K|F85jN2bSJ>j^sZE%Dw^vz*psTRC(M+oqI;l!vKGl_GNM6+*&-n}{cH9N-;p#! z>WGr@SzAUS<+i`dAsvG=DJ!3T&fYTL7IKv0pSK61LDQAeWg@EQ2-C2;yZj5*Oru@? z+$8Cmc$>#V)LOqXI~n8`>jqgY7>SL;i+)GLelK?NOz8W}5~QdrwnLzaJv`xGs_P3A z{^hAn_>}kP-ASXv7su2V=5E{}_#%}%1pnaDHN@? zXT~3-U)3}1UPXH@DDP8eMxB;aFU|VSgoz21xvOwgmDDya7Mi55D_Z0NO$S6I>FtIV zj`sUIk{hydcZgjwCSzFpFD}LmwYib0gjTKRgBy1>AKbXB_`n)qfDiOx{d_=%`}hD4 zamr-Bk)ajRui5tLh>HN^d0xDhT7Py5s;3}5}Pq|@k(fM4V`+Dd0 zb8ZVaWx`GA-Tr02$kuO>ZfL89@u}kp8p%gyj&oaVTXsxI^8B5`J>)-C^m!*jugH zM&00r^k4Nrg$MlM?9RjE=sNrn?uhi`R{BW2?!kp_Q+!Yi<&Sblx}rNO{iaGSu-^6g zqp9TRN+rj*W8!a)4Zj(5$GX9iAJRAHH|wL%Z*fBozq;CrR{7)fu0Och4g2H6&rfj2 zyAy`}iS++OU6T~a`;%z$q)L+~yOU#+r-a|&Y3EKY;cRDZo$gL^r;lS?I#$`dII;pyZYA3U_4*pSsK3<#-8yOY>^e+JTQTOr@*YNI|^gG$R0sj6L9DdGa`4}z)cOoen$t}GE_qB zcjjOliBu}ir^3}X*A?w9;ttaj<&_g>7b}G^-9{d%37OegWb7?J$@s*DlJ3oN=Fk<&9=V5I*{NM=oF=lN zpBe8W2{m1QX2H#j^O}#2%dvIl_2ONf0uvZQIN$0jPdp3FuHC<7+ejp|(b}EW8Si5 zo9^_7VP@FKT=fP7vIlJth+D%E{Ae8qel!OH>@Mg2U)IS+ocpc0WWVghH6DE&TOMkU zWG2BR?BOlG9*N;(85Sczq}3IoM2?UvRx=8NhKQv9ZoTT_Vd}bEIvj|Y?l(&3{ob?` zIUeEzbh|l&elBI_xw&p$+4s;+k4~_aozIH}ZoXSkQWOA3l91rSod+vub-h9XRIt!5ROk@)GRLR&yWWW)^EyBegltI#af{$ALcRQ`SYs}a@S!$R`E*)3ax zO8h8XyE{WArYs~kdqjU~?Gs~b!XtW8bwk!4qPhd0e#t5!GrNeMYXhC5zKQsvW_$PD zNqg69Z9kv1wj&yiH3-i}81u!hFhu1!zBX)8WOoNg_DGV<&hCe1cRaf=+>mg!)HW?} zv|Gn;W5$aWpYy!i;L~8n(tps#MFuczU?!7qp=3s?@^Jb^8}QyN#%$JQb_uz-JFeW` z%~SJVOgeqdF2;L=ulPnA?`2a01GC$f%f);ZCdLFaL@)@yur+Cbsz7(s0HBdlRH#oT zRM}ED!Uvlj=Z`0ywQ`kAHbwCbQ`h~kv|)z$g1>UTgQeI={zqf>$PGHRjY57RWFrI(j>hTv zYNRnfq~qaZJ;=>oZsssMwNva&fNi$I#3W*3-0ZUNhGXeAdA)+u%!oM69O@Hcz!?F+nQj11vD+`@&!r^*oPNKI77yTS2HUu0ZXn_`E8GeR8NfFYr&;M% z`c)F2sM`61sQO@ckUMyo5J!jjRRy<-AV<>`B`gix9>})z#|{cZbIZN9e%-A&@o_{piRFZo$J< zpgDZ>qX*jLio^b>Q1WPZlskIZA49Xph>532hd-9)j;%B|=mul$L*X}sMRJ=rQ_m^6-TbUg1GcH8fHQ{APx`B)}^=OP4Y^mzMlx?y^8;y9#ehk~BMRQ#;`sT1-LA z3Ae4<7_?r|f)WYss>$mk!hv03)NY1f8%r}Y;M!gEi4bGyhwA|C0Ee`V6Wdo;vElj~ z-?eOL>2j?rT4El1yXnht4Zs~AYfV;E2iZtj+zTx-^{Xk1Q5|a+n6kKAH)*6E@%n?F zK#{kirm2me<`g}Rq8Wrs72SY51zmkrg0f`{LCHvpm7W8IoD)EFDhfJ^x%6yquyIhY zx)Gn|#bevUE5PAS%7(2oUnM$y1s^U!Xy&`#cqsRw_&x%9DI^)H-R&E9j{RysMq}7< z$$Q@U2+UcVrg9B%8&q3ANBbI2NS_|`_{I9@h8O`VyCv~3gtAM+D}$9w5T+IgQ=2EF$zq`|sH+%jenS&q1j zVfNXlZf2abZdMX)c~~D&OB*oxG~@07=Lh7U6>f{IzMJ_pskiLsQtjLccE{s$E-5}uvM$v#%;7YEpvFdHH zv3Iv7OLlqv+tZI)QxGsIbK)sLg43==c+;T{1)+q|mF}=BN?;)^9OgDRFB}9r%_U4H=EEt>bqm5l z2$d~l<1I`-sj9*QnTzzMpV9;E#P;+fHn@1i&8A03+%dN@EJ-1D>rPb`1J)$ipOs=+^T|~odTfTK? z%7wtlp5!aIT-ndET|7&>*h=mVLE5`^PtRtj2Bn$Irn<#LQLuxpYVDY*Pf5E~JDi=W z=H`pFb@OXTeK$MT$}hye2P99os-U~@5NjW|PjwS_g#FnWxZjd@Y(6%p^Dr63Y1*LC z%E$K+(z7odheD*gski&4lkIAKsn99DrBEkAd=BfD(Ij!h=wl$1T%nI1e;}=`q(h6{ z0gkAjZlzlRJ6zf7t7v^yNvh1g%2t0?QYCRyW0!=4THD4+X!A`=|DfHCVO07*;Sb)M z=}r2_u;cQ>)j2Njh><##<&W7%^JZFiq6>q$DxNsI zAg*6;O;$B`YBsdkevEut&u;K(Jx%dxJ)DZ2@@YMP0zR#WLxXADPWiMIE%W>mm~%Tc zBa#-~(oqhL?)YWtuPXae0;C<5eB1%Is=~P)M41pKH!N>g z;dA-q$ZTxQBpX^5idy$Vw5z5l+qJlE+V!voRh25GXKdgo54tjbI$|t!RvLM?cPJmMv<#i1ykS`>C>5QvD_r)EEHb)`LEl5S z%;vG|7eHDUh_qTc8%qiyjWzUQ5b;sS)?3YO^g04gH}#ql4no@(Ohf^QBHK=a&}g zxD*z%hM$e#(}AJjN_U`JSz>MTZdK*i6>y*gIMC(}$u=8RcVgkO5DSmITT?O%k98P( ztcz@ny5pjKw%F#bF&Y^ja>xv?Z905gsa7;*$fy#or!yCX|7<;b?w z7j~asuu^7_m$8QNiWNs6*eTOZ#QV!=u?A@(?J$?E9Suw)b>B+Jb6s1i_-5Hx?pVqR z9%`~5lhwxdRT9|wNXs8_&j51Us#_dV<^>%&q9i4gbS=KA9_bV4WE zp%N8dw4-{>jwKSh#wR8c;wHyZ30-ZwC`5$mFhek1vQUb~Lc}#wQ507%$2iprj8WAS zB11Ci>2vLtmRb@+PP?qftBJ4L75=y_z0;7{%7~_=&#?!x%dhC9$MeQ7sX!Imj`$_aq5mOwhva71M+yt0y- zb&OKBR&OC{V+J(Mmp{B(fBkqT5;m=;aAE?6A(dT)t&O;u$$qWAnyG`#YK$efy1tbp zbF&+6YRqB8(&T!P(VHlnQlTcbx)kE`1Kru$KsL1>bcMC6=;Ar>(}0_L0wOUY4U3yS zYTU~#aHiXA0V6}*0WoSPWd95FQ2GUvOiK`@p0J!yLwfcYnr|B@qYiWil4_nAw@*)YWceN8_doDx*l)kmHqfJBzx}W(M(Vt8u6PkU&Wdx1ih3=9Pnm+5( zWf*;5>MpAt(t3Y6BABH?Dfuh;VN8SKuX4lgsv&fl(f_*C2X;;#YB4~eVvvA=}0p$$~`@rzCK&yZhr&iNrmEWEMb^ka5trI z$leXeJX>>NsZmN;X!9+PW%kp9W%dmB%!=9f&HVJ{K)OOZ+x4-^?@-c#TN1Y;aknHR zN{_Og>?kE=M`=-Zlo=#P5z{w=1Sv|Daz~QhtM)}*o~75%qVThoASJuin>GV~m+BK} z@uxQfuXIK8*vQo|mM%I-Ew12Rp=l`Y!VGb)MIIoFJ&6_o{ep|Lk zcJol_M229^n(I|6P2X)^}zG{n)bQADkLnzNhV=|5{VT^cz=R<4Lo-cF;A)nVWCIO-#;z6B12mDv>kMSKK7IybcT1#hyaOBEiR_>QSWsgJ9UhFagU+xCD%m|d=umrR2aV{w#o@+2 z0v0kUaBNoHn8vni-}=Qh)l*1=&lJ)kHMw&}8(PCsr$SRT$D ziuMsyZEfRJZC~6St1}u6cFuu1)S1XOvUARkzWsJ4>(#8Cv!TuCz5<#*p`CL$mZp=D z{<%FacSS`W<6vZV&f(BaWak`^D7uPToYk(ga}G$94I|jk7&LA+b-~U#9GA>SQY%!o za}H-x&r;b(>Qz5;VU`yo{s6bs956tkFh6qx@(}C@W*1rbjOB#SxL5a2(P3&)Z*{h3 zOrGuX$xK|`jK(I{Ra1gy^r3GwZX?s}vspN9Ax0H^0TLigO;y<*=#HDwRd~hjSiiTYFS1s5 z$ND*FG-Ul84uq**D`p`RTR-2eR>xRBGh(wR9YOor?dG9l=6INvH5?C$M-?k}Q$3hD z+wllzE7*|Uqgum*;KuM0J<$GaPhV)`l!Xm6S0F>^_uIEdhR{E5O%AEv zL`^!jjN1>{#6_D1vu-j_LL_q!m>Gx7BQxW$c_ub9W^0&5-3WFEb6k(C;cY!^2X$i) zWtLF!Oom0p2ufYV`biN5F@19TR`#St6ih3-r6X*FPGTeF!Y&wL7qG@9-^YTp1>9m` zt9g(8lMJ7*e_|W-K?Q6JR*jF@0BY3CBfEWO9;t^Z)P2CM7?$CaimVJDP2|u;>~YF_6E82E{2P(0*kG#R`Tpu|e^>HT$#}hC8W2 z@jUvW@isCj4osmL6l422ehER^#MXvxt)M>#%9BEVdu?#GRmL#_I#?5nEFMHf=3_hp zA%p;y@G#EH!#Gy7hKkm@HEwMQ_u@9Jh~xg_#~pq>CT)jO{7{(@Z@_+70pbFaVDC3V z!4G#E-Qgvyi1Y3U?XH$!LLA8ZCZ298;X_=+f%pg_!DSomXkHv$!jJfvKzS8Wd6!}+ zhU>0r9a?#;KnO2XIp3)ElcoE1O|pKc=eD7ujUXr{&}JpkkaVV=)|LM>#{n z=dk0eiQX)H?lHAf{bZO3>+JtdJJmC*en<7ov{O4(PMNJrO#ocNct`WsFC@TG?#2${RYbh|p}Vd3==sQ8iM%zs3x5$`=DQv70L<(1_?& z_fupstbD;?K2zC8J=)Z|(G=+<_%2Fl?j(HnZ{*3reKgJ(8fEHjNi~W~D`nu8CWy}7 z*b`mc$b|l5-As8$)v@eb)=?T5t5TGhQr;DMW@o3Jb(sd`tw^gl&5jz6NKEDQ`D&DT z94onY6^5%8@H^jSOug+dbT_D3u+E@4!T~b8Z2Hqr#g@j|gJ8({K+WnmJH>R~q+<)0 z2vBcPcVi?c7F?KpXZpRc35=g1G`x6vqGGe$1Xf2d{*d*}v7@m{F0rF$#iPW`KQ`gH z-o+)E_x|r&e9@NcHS687cNw%k7vtP700{IR$+Bvm!iMr~{ zIO_8X2sqhYBZj~Fs-~uq5ks@Orng&djbaNGm;&6tZ20e~+sw5A-Q!ZWg?X4LrZhlE zSkY;$sGZodpKdE^nJw73hBe2#KpdIjokaN4rdAB60`zRJ^y^xU2>i*>iI*J$dfDsW z&?^z)v723%3)8ZTr74U&rlH^(;XF-C|5+{2fMF6Pc3=$2-&Hud8VRKFCf9~!lShtH zoBUs5g;io7X0oerPPNBVuP~5BrwFC*(yG$cv7W76g)P;t?wtIg?R-b9sY(X3J~q44 zzH1J}jdt4NB)8q7*|qohoX zQ=Z3WjWR0%hWDgVW~I{f-!-U)X0Xj3s-IYGjSkh6=V;0Wo9*Av9^?K^c_7X1ig$&9 zgzKo0Xf@!Q9E)|=fG|M?jAZ_2x3$_3w^PY$i}6uTxo8M|)GQ2Ga( z5EGCpv4F74sYD5^iPXLoAh#N+ovSjH3t8+Z+4;KeEn^Zq@HfCU&)g%%J3D5OzX2#Y~LWF+|*=gV{+9RdAA?_r^kdx;|uk|dz*vb0G$ zI_NrR%U9!kbyQ;tp!MKgUp3BG>KF51adhc7p`I$DH@JceE&DntGNX2mog zWpvvElIyL#EWV0R!01?Mm8_)rDrq|uRfYHvf@SRo2lL_(cW}S}QG7^*K)Mev*C2GR zrTE(532IoNLJh7509@k^t;7e|KpD#waafn`QR4|f7A`f!PAfmTog#sX!BY;?+{!IYl z$8xQ+wEZ7PW)aFqUI!kmizemYB8UPJQ8b9eGUP1t2Uv%Fw*0TV-CV_3 znyn8YEwMw2u{0m4I||hbu(TizftnQ%;``S7I2;9l2r)~f1??re-*5HW^bEb2y*Td} znp1c`A5MweudA>#Bm74>>e20*OGG;<9`CSuMR;gh@mS?yy9&FfPqh9t(kD)D$&&j0 zpawgwCjfC~C-#MxO`Hjz8EDG>khDt}l0Vf1kqS?Sr7w(Dqwowj#$dROUrIK~rs&ZV=SFPX0;;;A|< zrgfhmhS62HsuA|wXq*6eMGMIk;8ei73eMEwS^)B1_9dMjR=J9?W{q9mY-5(NN|$9t z83Ar!aoK6;x$!`cZ|C{BYD&hYR<8#+Lg623EWn4xM8f8x&+?LVuu^1?jKPL%c`B^L zbpbZX0t>~3BYGh9*EtIfg*buG#1Ld?uA5JgA(pPkEm(*;aF$zm9dDqC{koBPOT$;T(72>I zpbY0%p`4uqF2(P>lxD-dFza?Z3J~@R2s73vs@c4OAIv2_<65V_(QK#0KqbZ`f&4SE zaIPW^OeuHc5O*U%GT0V-@t=``GBX8c=eibF_7+8S&S!A}7H@S5O{w5k3Wm>3& zDbK@|yFx|do@-C9LSs3eiYN!zi*&KQJUX$eEPuSJ(H`&$Es`7sdbn^X^QvIkNGWW$u z+1WBi^lOqp3IlF#`hU>mnBHAO0`}~nB7u_1i_Dfm{hevN*wGfEh|8QmvxtNI8BK#^ z-)j0UB##D{))cd2uC3Zxz&8)DeHR=eO~ z+Kw`z&$Zi=WvwE+L}gyr3cVrgU43um>uz#eea>upE2S*mRR5;YziCi1Z$@7gNzL?)SEBq~E0*~iH=Tx%y+7x`(q1yo2PQc7a>+E$D_TVi*`-5pPs?iy2Wzd&_lMCqFcW-m#Fx6kmf8tZ`Fi!rEX39JYPVXV*cx7~iELkhnRG(8V{*0@ zjAufEAT<13RgKVuKUJjKAS+lv%*daH# z`^eTCt-pPJ0#4X*~RoGCiX@Vms(;j6_kD$zm7%Qw0F)2N%~V*iNNywz&=@46`XSYl$Tw zH?`XS? z#SR8_TV|jY3vyF@J)aztRo2R-HZdWd*rE#R8wqh*nXwRIJtM}^{h@nG#JGnW9tzf5 zPmE8Rm>36Yg)5Ziw1*>L6nF#*Opc&YNbkZpr-b>}I)m&f5s-Xcfc0kGW^$^;CmkVt z*&xC$I5Z6UMJzONU0q+^!23&tQ!}TQ<83|U1;6tFbZ4g@0K1cFT?q`k3pnQ=Mt9^Z# zl0)^;fmJVb*KMdF{~ZuuE4UH6-oq3jxZNEdNxV`%8^JW%t02K`Zd2u5QSVa7?@^+{ zNAvDzfi9VfA@#?waf}9+JUN2m<~nB2Zq(*@?ce`NcGGcsgAAHZUJJKyG{d$cuME5;61lH*vBLq@g0jIYJIGB?xS)3JfI)6EXEWF5 z7ZcTeaioY#xGI18r5aSmJG7)L2S=fz&nX#!bnj-3pB zZ^TaiG@oqFrgL}L$!szob9PeGjp7(~a(sSM?Xlt|tK_lDOVX9Y-C^$V5jaRvO_m^6?e545>j)z$@>rzUQ3&xz zjX#k*N1Nevr0R5Z6oXx0lv+gRK-OS?9`7hX1)JBx2+Hp$(t}^9(44cD^_0wE6dFCD& z^B3cynd=C;vjWIDI?JI6ZR}bxtNS;TN)*Q*#aSd=3tX$+C||P5D&Ao=c@_;FnaA$2 z^t+Z+Ps>pa-k*k!^b%d-%T~)iz*{1Y6KLC4Y)+>!r)F+>{dk+MOlcY`#HQ=AT{vElqpw<1?SLreG%`Yqv^h$P z<4>0I2mU-s_OD*@wO%!0OjU21ngkt|Nn--%x8e>(hpjOd-7;n)bAbkP(P*2~AR`Ai zOeG}Btmx6GeP!VS@-tn&>Ac$R9NgCDHRXD8? z4jbn_K$Q`X4LclmHT{|RESP?QKji_mFm2*wFPxin|hW@Ef*m8~G7T2|AbGzV65*+>vFv2Z_I+ zxw}KVjMWyOQx79EXA|8Z_tt1wr@r!S=_@0>srnacr^(TFdVE)l&12;f6KlDdgH<>h z%SyU6)`r5(>MDG`X-O!mFSNZIF04td1xc+&_c2=%+-|zwO#B@$2L+@&g&?7qbF)Sy z0J&MCc4Gyke2OyAcbnD-?CO~McQz*W*f`lvn{N;315R#4NhZ5uCOe4_<&ym}0^fLt zijho2;cXXIP5=j?H>;ezNhbNhMoJ@*^1WDPvcI{RBht&dnWIco8nJt`#5D0&qL=Kg zX1Up!=w;c6GL?&JvP7#r*!m?1!sHZ`1+ZoJ?%~@UDHJ*F)BJoIwA)}rGM!r>B&s(y zxDP`jzjx+kyDvv&KOXI87FLng@7n~AA~Y2`e7n?G`Kk;Ut-p@n4PSzk>I{f9)#U zIt5l-XB(CbR(w`O#PZ*tad!LG zT(U4*?wzpP6|?$XVYfv#6$D$(AwiW?Nq3rx!Iqyxmz$L_*d`=q47Pr237C7Z$H}wM zB;m2_%Zeq{!#6x3OvcMg3ndjwY+^qAGwyd8OD&>F06w=+0jGQ8W?3MXIzRCgOeDiJ z4ZeT4h6Vm@pxtsO&CH?xB;fmh*j>4&SYWH|v1NgOrvb2><5}R(<&vcnuV!5EaS@ah zvkEUg_DR5rT)W9@+I7*yECyNvniN5r4t{J-JO=vfNhgwKa3V=RYBO8$6D#{P!w{jA zN*XdtKiHcpEJ#`j>ea0$a}X~>Qrq-nR>eFz1N<%9vLG@J0U#y<5M6KC??bKoL}Vim znz*m(*pFH(q0zmb?Cqkm(H)clrri z24CFq0nMX#`=d~GQm3Z(+M7O`z&^LQj52je0GaZr5|*kX{nTu#gcADGXalm;Vy0pi z9R`f%ASy2o1ZZFB4wM}p_8zO;L4$-Cj$ZX;znY=1uJjyZ57obx`Z05M>&%;8Pt2j7 zh?@M+jGe1G4BgNhIV*>Aby`f#BjVC->?$-TH@xRpQ`JD+T9cBu@wGBG#FK$JnI{(` zH0^`=0ceB-c!-L&ID?q)xX$31Rn0LS#|D}Hhbi#@nUXZKRTZLie1K%rf3k(1#*|u5 zEC!cT1g@e3R_c-Nz!gR~{%FER0|=MiV(i&W-ddb3as>e+c8zlK%@X%`J8Q>J1ii6D z6WLNs8R!<6yi=h2O;ZPeNh7GqF!qiK0ccI{)P!IU15}-U(k2HWP8lVqGhU;KBTNd@ zG8$-N`YM|ZR>v;>;52GegP&t{Y8d%MsPK2uIHwnf;6>C1^L-IJfbYwO zmU(>O`+_Ho5J6>asQSG40?XG)fvVr1wwL857bC$>WDYz{VRdKen|jAb2PE4r03+GN z{AD0>A=`5m2_MvN6nfo(`+tgWFV5PtZVh(6^Jxhtq+eC^`vr_+Ay3BgAfIbX&dq3S zjxrNRL>^!hnNteuGQe`X8b*Rq25qZw&o(zb)3$1_^0T0#)?Q76;x#y)2B#EA3~niA zz6Hb0$usP`BtE^zovvD1l`Zk0Mpw}P9UW-`$hXCs)?^6vlrlxqeP9k@@E|HFrAW zKfUD7D7KN~_zZVuc7L#a&Z6qGN~8cf+n*EF;ZIWfpG+Ojc0HFO=a!WAxG&hpK!2y~ zUW)do63KQamqiUtvUS|4KY#G%x3W+nk*bME^Ipi8U$<4?JKh7voy7~F7ASOcnM25I z^u#is{IOvdn)0oEbcK&!*9afa)|Oa+097M={3-DFJ8f(3DdEFvdu)Y|=V|~Dr^lV} z@m<@(yCr;l&#Ktd!bhl8!pHYj|Kmvb2yp(M7Cyp4JT8TgFklHEL4Wb+2p<(S#$>|B zlrIP{$+=bLC~d$Tjg=;L<$@5G7a~F{9`tYQFr;a)-87yk{k1*Yn~T-1h_VFua3#d( z8+IkkfOY%x&kg$HFb(cxRa?VR+;!jB<`w;B82xxgc=jx|J)pIY6DM--#4DO8Qz#48bqs@9}oV!8_N z&b7|ORlbtqF9-KBF()kzKAg0LUFw#mJca>lXJHMgAZtAwlLgRji*ftFEYdGo$SxvW zrC+qal!+4|F#T2~R+n-nFsbQlG!2@bRKRD98%7A`_!rWlB8Zt?Mu;FbO8}^NZi}Oj z&Ar&NZbS(T?qfxB;5>}&j?o9Lc7%`g%hs8Yi3`kgLrYh&3kE!2pNZ?!D#esk`S5Jw zunVe0W6M)w0*`%@vD!6hihqbtd^aEX??=Z;CQU;PqE^U+hGks=QHQjL>F?FDS+gtp zJ|(-E6eKVv=J$%!N0T$DF2utMosu;a-Ac2A-xzrsFTyj+L3XcS&bXkF#hVW7VlwOX zl3Bg^&zi@FaB47P0%mi`cY&I8l_bT-Zp~~KHTm(BwXM5iqAamX0lR8_h}pv#U@-xk zA~VWrD6~)4OmPRxU{*83Ow5cp-WfrD-m^Jjw=v57hv54FZcqaK#Qj@kMm-Exrg4Nmzb>4KS8~n*g(D zrP%{oX^y{E8hl)f%DK|JnOs6fG&%k=GnAx@LMy<+{khP}(&7)TX5e4|;FtYU6$%6tf*$@_HR1uj5!kk&yqc)g31GiLD^$c%ul^;o!4|9?PlmNIlu)HpZlPQTugN z@%Eo-F!){zJ0=ZYthxmR`Pi(tgT=2}4~N{4-(0-Y6nIkl}cWHn+Q!lIpmQ)BMpGVnZ>VKZ_jdP2}lNC z4ppn39)FHINA*03QJ?Fc6p>^-IUk(){1Un3DV8doynAx`m$puN((SjoZ7OylKeXiX zC4aHISWhl-+uS83f2oRf`pevB+FW+zl&} z{8i~YE9LW~lD}GSuc7=?+%@hgC4a5ER!_?AYF94#>)drU9T@Gxg+V_cV8N$!`xM z+Cd0hwDuUyETbK1|#ZLA~60iNoHrns1=esaiATEtuT2~9>L^c z5uuqA^?rq6cE#8J<}UWhG;|FnT$o-K;)7CF>^`M~86?s5oW3cxX1nyW{gLI_i?2k} zRm4$~^)|E+zyK+L>|5zQn(AOxX~f9_>cRxI!}8CX1?Aq+LK6}Ts__ZC>1cPY-4|K9 zYVE!n-&13dB1UA$g~h^6-({;_e82h3Dhh;2L}scG*aJoz-*z(Z#vYW!Mluv^n3zBY zXi1ggBof4x#gq?Z2py`$tn{5LQnAC)q@{nYhFKj`sMTb}6K=AbEBKdT1@HXruC8D} zz$RP4cRzks@I7G#e>~|5hPQim1^;G}6(r<%_wJv;A2+jt96*j>JX>uNzta2ELpH0O zyG)%5?h+#$%2csk!EXC?7W)v&XQeN*pVR@K?XG)6%K%%|AWxa%&Fu?nKaSuhb_J}h z#rURWNAN*YUNt&`;qAl=XvB+C$hm8v$+mN6mV}jaHxXvLo2wSj-539(iE|fMEu5#Y zYVU1+)!z5muUb5IpPY2n!rMKtYS~$vXw^=wGWGSBKmg7S`K=(=TveL`ekOWt`y!hC zZPqtSu&#gv6|3|;Rpq%=k!ljrBV6}+Gea}EBYnS?7IELMXAU7?jGJbLb=5;ys=DRv zyl%vyPgtGB-v@PZ-GvwgG+la%sMlH-I99&I*H=AO>t`nRX2MhoHqAj@@Iu{9T$$OV zM{XeoqCDPO&DXX1sH+inarQp^3mx-Dq4gi5*$X%Iq_fwY(ciBhhw$~bMtiQo0gpBh zwFf+&Y~`CUTh#bYc{PbY@|hYlxt)ve#UQ+*MS_sD3I*>e21(O|cOH>k0XGGSI`Wtf z7P$H@q;y79ibr|QbP@an&N+=jlN1t}r?P$}twdK%EuE6+vsxTiUTaV!?VTOLuEHHP zcK(eiLdC5k*zj^H8PkfEmzdaCt4ra{^x_|db^`k=(GP!jg6ejb1N<AfO?Gf&JiDzAXx#5!g3|13c| zF??wwM0AR9Pv}v;_|O#Lo+%?%%?6l%d0^ZpPRQA8ket5{7e_Te#`qvPU)vStEnJ$C z6a#x1DS4lyz&@^zj`Ts}M&dcc5>L;y@dIyJ8{F2Bab-ix8WkB}4_UTac6V3cpL7iLSwp zuEJjy+SZ|Zp2vTuWbNdNp9Ogo;y8@VozG6Ah}35CC)jnqp=C((Cl;iAMaydB>#Fk3 zEDJ5;FWk5^_?A&Js#6*&|d2Q}^g&awk zQZq?jRU8PCHi<1TxNtr9Pa^JplAyk&0@C}TZx~z)g8Ze zfw~|5=eEwwwjhah=UbRQh6;sMDXvI-l>( z1KT@40DFUe8?{~taCc$ZUqr1JRcpPNS}%^Z+OIDOUAvTtyNq|2m4xW|D}eGYErIA= z=`M-uyxNzjb=Z{xs+V_Hv3omng?Lu3=Eqm7VuCE&>R!WxYgk>|Pd)xA{P zKaI2bboVqteBgV}aL+u>-^|aqyPMtivfq&a?Zup89Uyzm6sR5u->u+#w~=bh-6o)p zvEQyQxAXLl#NCnjXC;n*xAFbiiFI8 zG4{ms6YU1)UywNdd_j`#u!H$Rwfv&Qy)f}FPTY$Ue^=u8pJ2A04_sarb8( zdVmhO2l)9ao7|=T<@(iwiFkSHgl}E3QnNXVmCj;?4Vt_j;-5hLNq$-mxK4I$ zNaKt(8z%l*Lu;>A_sqi2w~nYm{F*;j3Dr*CZKN5uQRnh-_OoetMx^0! zM~re8Fh>p-flaO$58zS!n#j6b2yzP`qV6DW0SRsagKntoH#7B{t4D4N^%GLJ7gDBs z%#J`edYv}82(02~7FJiNI~25=+ad3cr?{2t^(S!eR4;;fNKV-ObQK@7m72yi1L9I2 zTymE(MO5|5?2oF6q2ww?+Ma&g+N*Vex3iKZ^)o9JKhvm@L_h>7Ka)g^V1;rshaobr zmpJ~ktMJ$upbR#`f`UMc%%@} zUc3k(Xf3167J1afi%NXzor@Pbfl=8%#lUUNT~!lEFQ2nHY9zgUu+X;QPcFR#=*o11 zK~4DQE4_rF{z;@4?j5_QMs!cP^`m|RRBr`MS$mCLBh2(NX0&+7cMCRDI?Ep<bd<+94F753>iO#U!GFJzwJ~xw`m}! zJIoO(^2{0B9Qe3NfWa2wEO+)Ger*YY3O;RRe=hZ&t6Md!(RoyMUX(nHM?T-3ALW?~ zcy&QVo_R8N^)~lpj{p;F5eEIm)Ov}#*j-Zgms0Dc)mlwviM5(Mb9tE6E10+|sW#Xn zAhry*bL>=_$u}#_e9;Kr zqae+M8Twx)&4f-rI?~Lan|HwDcs#r0z0s@yvq$wKU)C|4T!4AS)Xlsl>D$$g3QgQT z_`dXiCcR|pEftVCT}RZML=h%xPA1ck$oj_6of->poL^d#!!pFFvD%Wne(Fg+gEso4 zi4bd7A5R_)U#*WbP7@Z^+3kh38-G?EqmY}Cypg|gTuWbJv@8qLrk04CK}FRlZNN#h z-P~d9+*%blLfI9onFeJ*EV&$lD=?&&8+RYK0Q85jN9k>bO70s<#GEJI%Vv0}E^IpY zav!`F7kM-k7LcP~b^0Y#NDe(uwvzxI4HDu%0T?>KEiVfgg4+otR}^ysh(L!dGLKs| zSk)Mm{UNk*NN8g<<5(ThG3zujdeVEWtEdi~6bJNV9i`TVQZPpA`L^D`7kbs}4~0qI zz@rT%z@o$Yf-TjdU4;i)s|g%hDKoL*ra}!Hf@p@Dm>z0%O`SB*K%GPhX`cCzkB+fH zoy@{sI6=sIyfe-;c49IO6YfW!qj_VeZ5w_nt+UmDiIp(K;1IjHE@z^`B_t}<&2sN% zzQl;lO(9`oK>jL=9WrxS!bEIb)tB)J6T40IW1~Vp=>}|V_}U9l=-3COx)D&gvM;R7 zimt*v9my>f6aU5`ThMB0aR4=S!t9{+O%dJ=%yl0tREVIe3|Bihv=CBdMauwQAPF=e zi{Qdm%VM~oSt~BAL9;l35!xkKUK$s74$m+=WnJb5KcXT0h!W0UNLD~~3nj0F6sWy4 z+$#kc*dm*ux5kAO-5yb@W%9q!XMnErfd#4vM~kT0(prM+QXJd;4rEQ{S2{jE`Z<(L zP$%b-j}8_{iHFebDWj!~^;rkLX6ii155cmOEcl?JvQ<_=Sy1IQd|jh_Xqex-C625{ zZW)@q0aShKB5=H(A{;-|p`taY?bP%Jcc`FRq~62a#z6quBmlH!eGpN=bGw6@y*CZ5jgJnNtqS6q*5AAH$fJrGtiQ`P>Jq{gSAZ=TDhSm<_ z`{My)PjDv=`IC5bvOCG0T=u8XjZ>=KIF&)1s&2GvO+rsjQ(F`}Ew+~W)A>D0yG-D9 zXASzZd2|jo_~(?Roa2DnkGuW3%(98QB@}b#qnJC_T`-JpF7KW!^RHgS+q~OWLc+Ze z373(#U~O+>xr7=obr)e}kFXoZf{3dUm%GdS6{zN}L^XHiP*oXM_E*u*tE$6^nz(_^ zX>lyqP${im@g;6A$imFR6V z2?Qg=x%0$XQJ0Et7J6C9on;vWBS*EAd$>M>U=2rg0PGW1I;a}CEqeWOI4WbZYSU*e z?<(BikyM=~o93vd0x{KcQ~}sAj!GzVV~z?$5k?_;ro-skjW?U|hPYtFB)}qZcD(gs z1`u&nAr9UUA^#GYM7f1!-^-=dt1B;bHm3Zja#fjbTxp?b(uu3;LBh#9UxK5OKV)99 z@94ESmb!e7Xv%B2s-@~?e_*FNk#s2EfuzIaQ$s}s-V0}&kDM*(W;=+2NBB{q;4wPl z-?>9dsJU1BHE>mH`MS0QN3{;&CGb=SxHTxy4|eO*0AQKEWtANqlU3F! zr)->zA`KL4xvHb!swP!_GnrCo_EYBx@!8>fxos!oqw)#(MyMJZb@Bp#oPGw(N~Oy0MO{x{0i2r69FcDFtKj$N=j#6j&qFv|EUtejR!Q;^S$oNh~^taS@~)xAkmfnY*k z5w>tN56Eyky{yLdVU&vO6L;RO2ZAAt%Ih?o;AS~xD`1zjX17kguGqBw7_dH26P2SC zd}Ly|AJQw)a-74au7PO`aT;d>D$t4hc(fd1!|92P-1(5drczeiVYb$xXeUsGxinH# z0ip~7sKc0=WpRIGTq#wJwKm=rgN5%;R@wPgAD#MXjT@=8&Y0qF#@lw|2=fjZk<;0+ zS@XIIKWa^m%vP<98_W#BEE=te3h0^}&jECF(``!meMVxd@^6osSh zU=gOX0z{7*8WWI2m=5I*L?pjT84;?|XS~aj!=d_uB0zlom|9fnqA z1ovsmT@G_X!Cr2hqm^E_;_W4P(g?}0Aho!Y+QUw=XjqEKVE)n;4a=OE6(AW2SX~WpZCiBy0`nf{q$F8 zid|1&VjT|(2wQGXzh;5UI0d+m#B8!#C-NPk=s&4wi}8?{Y849^<`|3?w-Apx5ujx; ziS1a-(?w=2DPmbqjG5LRgQbz2(~?67JF!BtUHpc1$3hm1ux61<%zUu}^TmV%vyYiC zVv@LD`Y%@8Q4_41al)P6)0R)atv9N-qk5Q1zK?f(>36bssb9>4#pze{AXpmmiym)~ zShugksfWhk)S?j-?&N6MZ_Ji4wFqzF!Ad%tfn;>>Alp6q!NI&Z1h&nXyEZ}B;ka0B zYXExJQhY6@o0w&;`UVu78 zi>}V1z*Qxkwbbi;XfooS$!D;0yu7+aI;)$eJ_WI|w%YV)qvQkKRK^7=gl%`-B1<8B zH`}EqeD`eEqin;rG2$j&5IdD|@Vo>FwWV!=h*Dz<9u7TFP&^!NfQatn+;waMUZi5# zoxdKgy-i%Z)tH|^hRSE)bIO`8Z5~CM^oninR(x-hx8kc?lS8sqe;nV6S|wt_Yx^T0 z>)U(;G_dXx)S4!w;#kCWV?Ffp=#1^y=v;#>gwAf=Q-Hsu;LbP&NNJJ zX_*upn_NFchy%Bbs+Lu&>gF`(k;TwD$sBo_6b|t=TfvKpVe&K?CfD3%tHN!Dm?qbi zaEyoQoK>i6ZS^)oT-)=v*>C=Yx7qg^-)6sk>~6EqHn`1RsovESrbf5f!zx<6&2mlO zW)G?X;@85{b|@InW_`N?393VmkBI%MYL-6E zr|FXFbp4Wp0oTF_0(g=O=TQ zbhrgJtp42T%xX;4R5e$13uoqVz9YI|f9`BpN!SLll9+W0UA2e%@heN5XBDAsFnlSEvI;_bsIvN z93(p`8dbEZ12G-PdJbBL=~lU6ln*0hdO3t&tmeh)5~A4}q_OuIt6&mY#h#@@Zj>9< z&241KSOwGA;SMD$5o%Qo8$b#}#*bAfS@DA@A(kDESawAEJJD`DB3EHk+!5oPVNe{J z00eYL*EDgY{7+MyVmi!A(jAMYl@?bAznJvD>>lXEUve<`OWHe>tN?=lZSRyVqoa~7 zqxi!Xl&u{#E|8irbAe>WXy{a4hC~@?Q^EfDdPWKO?@WIdhsP|4ODI%nW+Mt!KF%YG z86O?^IIwT*vwgt-N{0Ud176KmDY7rF;df>w{1kt!dQ#?lh*egJPv)+b zEwDy8%F7U@%-_hc%oMl;viDT~G*tCZLseQEku3e0WR?Z)nZzZ#G59SGN;jHFH@ZX4 zie;gB&qUFBt4w6ktJ2e(umToIxILkcb^Jd!ZHk7!0r)}IfCwWCKvj(0=LU-7J;lJGBl zzCU`Gr~hLUyBB2$-u4z*b?%AW4BbIX6KE+(hvHqr4;_XoIT@1cwcPJ-iD8A)W4yl^Z@U`l^10B?#$s zx7i#9to1GUK^iqJK}M&$tqepzaX#u<+zBP<>2!A@1D0URY@Ec`lK>#Xa6gPiOYx&p zz)Y|DX`Jj%OFv~}I-MT`{mSX?%ragYXPA%qS#eeSan>MIq&r8UBC%IF*PXZ3>{ZS# zxU>BQ4BNs)mi;zXaa;TmO=7i@e%czih;}bhjSv5Z1>FLR~z7A?IWrm|rw(=e~%@2fVn%++*kBxK}txt3>(ehpvI#H87x zrx>?TjzzEYFCX&t{^fDeo#ICdwzyHDR*X28Gd~TfUA$Sb4Ekp>n48@*-OXjco$+sv z<4>W@YOSY2p40yj0T+$F)jTI~&zO#P2AKomw2br8pt@%zmC1QFP5zB&I^ z5#F~Y?yZS?TeaS|tKLTv_x8j+!Vlk}AHGBNa^3Q?)c<9|VTG{&W#ayd0+9RZ?wu5X zRIAo^so}p)+`AI@*SvnWUcZ~yc5bx_bNzc%ivJJwn9~1wv#6es>o;d#acrxTa zp(Z|=xKAYRlQi+E#C?he>^IJTI&q)2{r{On2kWzm`%L0KOR>*sAwQqE&n5l~iTixw zznD1w_##{2ORDh8iThIGzD&ulsLx-?`rP5anz*lKTkC7qOppI3{p9P3`=`WxoeB9y z;=Y#ne@@&t68|rWn)%E34J{Z)*d5Cvo3S+;_4K(C5Fa z4e-6heK&F6qu%dpcD~Q-;M~Q0b@(4>{ePIaA0+OFy#F`7|2NHESpOfX#eYxSj}rIq zy#BFX|5&pvx*hgVkN=4Z{WNhuN!(8<^fMLu8HIWfCaf8D!Os&B^k3-JFDUcN#Qiey zze?QC6Zfkm{hX2AU#p(qB<|OV`wheUt)}g_*#O^}`2R@Ue#HtP#=%>D~=?gcsb!d%I}C`Y$n6uB`SzZa{D zyK?TuId>QD@7DXfc^{9TZTNe5Xv2C*&fSyq_vYM7a{i?`#~&}H7x$@(m*w1jIrlPp zald+Tzj~oxF{uya+ygmH>dSLTjSuGB%X99*+;#pHdhT99V_{O6z=vdV^GfyMm2~Fe zoO?LuUzKyO%B8pJrduFx^VNF&YF@u4=U$VG9Opy1uEI6d=t@&#u$43@GT3IDqTuk~ z{GzTTDbzaBTfU^fg9}2Iy)xr)cRwn@zZ!toC@R5jCSVHrQD0=6KIFqe>y-r%Zg)sR z>F3qHqTfr0UzdOhVdbMWp<S1F{vUMve*#)m7L-nHprlu(PZP6qs73hEuA# z-6>cJWa6dq`HXR_U4V=j?x=~a*IxX9=Dyuc8;5uaRpGn|oIx_{;{$=r@qs+n%Ln2Z z31oG1hFwo&y%LKH zRti@e!;c&q5L)RKekFzw;7XjrLVa`q1x|Ok+8}q~29VxvEbczkx6j(#dX-p@vWpS! z$D@!ZJD$mXy9%G}O#Y?@`FkYSU>=|>HW5%Qn+XV;O$AiY=HmJKWHO+$Gzhgb0Pw{* zLjdov9&v;mamJz63pha}UtgPp{8O4zdlkPaw+OI6Gg~pKbT7Ofo@KwZsal)k0uH73 z7F7cQbh9nLEn30ba?Dys%qzrP%@OLCK3l&oLM09Lv*fl+*~0X5f~Xhhg_f|lglI~N z1GjJbQDZIl(;Ka^!rVCT_eUYPU;0`7NN*PLW|7pweLhO0B)Pp^Z;?zp+)@+R=_tI7 zVR{nW*@Vk@x2z;=&oAdsfIX$IAK*{aNX8fyq20CcUh!qQdQ@*ExLy#q4&ee>?GACP z%fj_^CDI_$&su%b@H%yrwRh`Fz0w&OWBI5LeAO9LSznk&P`wo`?5%Nl9-c(INk|@P2Jqu|7rN0AiHU9$ zZ+@QK77pJ9my zkR@-9%)N>7^kO?Nx0fVO?l7?LmWAzaUuH@}?wpPR_JpFf_TZ1xC>NkvdB2SHJn5{-07ShU6v7V{Nhu_R%!194F( zD&pgd1Mf&d_A}BWe=yq!ko@s{xGDRCwYpCtC7%BwHd*={n;S$*irtwD@yQ4TAex&> zpzJ`PECoqYp~)!KDNp}U=|ec{Cz2sMkRM^EBtS}xC{RYj-8zoO7NtXSaH2H5bZaTF8X33JG{Xlj( z#76{5_g1)RWJq4U&1R(dhMY%q>_C1jNsN3XL4?!>KwRuVW-Li`1R;56g3zeC-jyI; zA}wkPI9W)J9huG?c-ur~{Tx~_Nlbd;oLU$4zTWkNr^E>d5?CZfGTNFvr&FFMD{`L#47hXw8g{ ziZi%+$=O8{(c^R>+p3pG;TDPWu&}Febv4>?)5f5%*d0s)9|~j+TO#Ju_H|$~GIO!m z8mR%lo+NX!NpCIIYCdC`wh1(#Y5<>824J>47L8n(H2Uc*$9tV=T4&VwV2~zQIhszv z-K3wf&f#k+3k$*;3tff*)!CZmT5vG_tQ{IHLt9L!!7>Czk;U_$b-StO7SQ#%6sgS* z*j4ylXYzpxk1_+k$~M6;Ohjj2P)>HbmJKb-;jP%@eSAn9;{#T$mk(IA9zNQH9+F!@ zKng~l8USpF#A<>dYqxcZ!LodJg3I|PBRhhO1w&3ZYtZk_@y#;G+O|^`S=YIuW%-1b zNmP+%_sn0>0>=hzH*=&BwhOx3QJ9XNDjq&K4iC>NUc?VgaX8`^JKQ)%{Sx&p53{j! zMaz8O&wGofHzMA`EgOZsSmFoVa(D^sHwXQJbQ*tXx3Ua3u?k)RUt#t5Abx0}R7b$J z(Z-L$QCP)r6zcI>-kYLu1WtnJL!)pKtKlTf;nE#82#&oRhszbwJz%3dvg|jBop75L z`eK;Pqufy!LOZE%tz0w*)<)XjBWVM5nOp0i9yrrvxC{5_yZ` zIF-j$CVeYiw1BB2;x63rqc9kZZ5|GoJ;4EUM2v+yc@%x%i7*uw57nJMnE3((tlCg& z8tOnVc((d`j+*ThUhSSVjEiM1@DQW^d@j5g`xLg}$!^_!vcH(lU2L7x zpe}KjsIE&@SBFOrsBf2Z;~6fkfTx$aD>W0ByG!*!u^wD4g-#RqlqUh5?o{y8Y$}w~ zh;n&&iv{wtG}eM;C^KUfCE?ZR2d_`xXlHUH6t{Fn!|)lMa<8%HquY@#z-4s8VW<;Ci46Oq1+JqwH!vMA z9Pk|#j$<<%2bIBSyhxlxnNUJhc9$xPKkgOdakpKN@E!EZiOINUEJQst5kyTep}5Mu zVksW5T3#M&fl=Vk2jP~0rgH(B7EAF^B7TBD9!`#jr=WK*5U&y@T@D;XrAj!4*IJd} z(%UPzbVys5NEr8OjT*gL>z(xp!ej^||+PzgmqTieZ=Ai;U55h9gBJ2XJ!y~i^ zNAQkp5IsViTPlciWq%k4v7%+i@9x@RTm+NUEB4{9t#j{Ig>Vnx&+lOuz&G&fZ^UKj z(Ypk9Qt5lOZtt~q%gG-7efs`B`<^Z0`vo~?&A?VzGyhM(v$o9NshJN5fOa3CnZMU_ zKxj3?qrWv&m0$D#N`pu17a!6uJ}hV&P`V^Enpc9O)t`^3eL>NCNqk8&L z3V%!hbi7pl5oYG^+xF@v#NJ%~%WZGHxovws{+HZbV{E=EsI$izoA+~f)07N|?M5{2((2XD19D0zcY>|wGEOe*eG<3+Utk<=6#Ok=M)CgIh#pL8w6>&Z2$U^QTzF>D0 zOCmFyQLTld=;kKlZJ(68zT%TGVSo>nb4bp4Z-K(YvMi-N1m^)+)mW4L#SgdWTH{Vz z#)XE-{y@8Z4^*F)wRZTG>9=e!+;1px4|)st+Db09gM*BG8oqE6jn}xf zWp1=}=!pN>cuuZ0Nyl&DQnPC6+}=*Bb9DB2_Hyf9a9`WUF#;`9y?eGV1ougThi;R78>2a8JC$g4wdzay$W{cL@Z^=il znnF^icYk5W4tw4!3@rVwp)vF57%&)&o33Q~7htgYu}2F)y%v;Ut=io}@p4wH27|$O z-ZTw7$-`{%!7eR6BiJ95*roe;{vYTLmT_DBBKl`+R#|Koiyhi)>@LH(vnUtfImT#h zu4A;ACs-{TOsBS_$o9cdZL@kDVPAsYjQTa{SCsrmau1XjLw7YXzD>J9JmdEf7sN!j>tZ5eo(Yd*#l$|CaoClf8Zl9sVfU1n z*gdhBm6Wf9JK6@gp@@vdkIFD4>r9tNn0jG@*cK*S!+Lry{m!< zDZ}0qqda*0pEEP~qGp)ECk!8+Fnl;-uxfE%_C-!)krSy);|WIa2}baL86)`Oi5bDe zk|!9!$A%I7cKfsgVFKsF0JihF_s$u=J)|EHBiAo0L*Y_g;8K=dVFa}Rih)s-)+?m6 z#=>xRz*z@zlua;rAR%vAfU4_JbYe1SF7y)w6Arb9nBIh1D2au0`^qGeX2$^jgMNQ% zUWC2eqB3Zz;(4po#Bl#%$${{3kw5Ks{ld7GQ8y76GOqOi16cw8jj7To2UH(%g`;xg zK#Uhw@|%^GClsJn0fWg8m;S(5xPy6ha8B z3@rwMrtp6@R#?C)C_7XK%2G)N%gT)_FV4?xq6S7#q`hJot?EH}AmzrSGuxD= znAcy*nnR|Wu&&3wRq&)3&ALn(r)TB_mMKGdGBRHARCq(?n0u~*iEVcml`uiLIC7>J{yB4|_ddayKEatj!I}Pl_Ra*b zuBux9_nf574N03@2oOuaeV{;q77CO$Ed_g_qy^J_yjMIo=j^kmvxl|U`qsDb zLK^fZ`_Jnk1Y1Z{|9{xFYso3Aj*30Z{plcx)}6a{zI5^Z;ni&Vf(>E(o!GQ2^sS3ZSD31<<|}D1bu9t`-Fl z{K~3O050hl1<>wM0HViU8Wh0j8WaHVOhW-os8egzXU$8G0{E3j0Z4yZ5DWlS>Ne7& zx*0ns+oA9@&#V%zf!k;L)6rl7>gA&4c4QtDdB(w@WG6 z71imkraE1xE|=^^ts`fkHOx3v-3nCE6mo}0`v z)dM!7O+tOft7Q{-w;Xn9VsKBL9KhcHzr8EhH$rbM_?LD3@)?W!sbmVuq1oY*XpsTEhH5x3#0*sb^;L{UUuG7F@l(t!d6`)P-IkGWr9ukHnKRIB%?jN&TQpk? zKWMkc7=T3Bo7QSd}!F=33A-rI9Wh2lK#H}-rvr&pir#sX5FBW9fyqUHY zug-kMs}t4>Shm8)KS$Y}V@wY8T|@F7yj#uCVbHNqYvp0WfVous7b4w)CF4TqDlQUT z#peT?RxbowaGgM|bum<>k-H=kl@>oPi>AYQ!F+(^0`7~;@nD7V;tF2_5uJE4t!9WX z*bJb%xKgAS#-){q`a+J}-1(y9GYA1~HeW@JY&uxV85Ke= zShn(zY^9>tx{+MoMwFIv0)%2s6G3p%=6mJQ6PkEH7|sL5q=x79)jR3o;DIwKOsyy2!(Jk-~ui z*F~~O3>d;M-Y?z@&w-)2`+$-?K(YtLc_HSDhpGv^;J?U2f02s%;*m(a%a3M{)kzfo zm=StCu5^!+?g=q4ht2shI53`w8S}x3X-Kg;hGt0A;JKw5Jb!@2(o{%Iq*#U2gnbFN zCAk`TTGfUMtttZ`FiquQ4rmCRs*+(t_!0}H38PfebC8UnbmI_60kpP&Ze0P2$m=ye zMly?4W@`$>bwy(j@X<+#A13wyXjNsqCX86&yEdLa=3{aZKG1y(rV{^H+>oBis$Dml z*{tBWC_i4!<=}|)R91O*FXD`eM!+RWpt4%sK_xI^UYW{j4U%}KNZ(T}O&2a7onH0` zYc3)W8UJaw+8lawxVWq~b;H%0A&TL52n8e=FrvWJiriN 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

      W3WfqV2Oo`v7U3#k0ZS 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 }h)Zr!;nTGJ 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⪙@aNR>so2ga1@DD|MVlP!&D-c5_nO%}I;h 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

< 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

&p&W%RVZh?M3_9}`8+HD0v zk6=ftYD|PP@Hfak<344FK%26!ArDqa>F>GeLb$-3r@)+i`dm>`Fz**|fAn0)_{`#R}D*Y z3rPIm1yK5kUhuQb$!qNf$LyJOC)u-66-3qC;Ffe@>YVDE zZvV3crqLS6GVfx2LLTu4-9Q4eHv}!4P|Gld;qQ0Z&mcUDes6~foz-SlK31(pAAGNH(HYL3bjd2r*1FE3L<0vSW-VDowVHKJuU2=qtXJ6zqxcdG zxaqR?ISWZ7*sSrdW;Ev`qaQD1A!XbU18^GSKwOWPTG(xUz$c)PK0@vJfCiU73w~v2 z6tVECRy6<-0ZY61eoQWcz2>0sf-cpuo=b!uh-fYVTVE_$*MShkbUWXvc#N-Bj|~~Y zfPt#(KHH&WCmW!Bk`8-xCNeKUNB2{@Ui!af7}`~x4Zo1F&nKFzKGKnFsTY@6_{ADG zUarF-oK*K;nZe=7%139UeuII+q+IaL_{baf5lHl9nH?!(%^!<+2q(GWsam^C$WHO{ zm9kSG+Y@Z%Nm~1p&8>Cn*4!4Dtj6d^M7l8E>;;*=!4JvY1u%j$(j61o@Jr`)bt-Ld za%$oRE9AZ1GDJm$edYjWt@Csl&n^e%^-y)h>%8M+jj;(Z3h{osHdeRKAE5v|6ypb981T#EUrvg*VCmdG``usECXtom|RCq#nRhijwW; zm%3My==Fcg+Fk;gxI4UHpNfPH&PAPls%*iEPWISziPw^0Q6zdV$D)om?$^o2=SBFu zrpxKwD3XnnVX&v22K>=ZOPxW5Wm@nx0mFx8z$o80QM3n~|5$gpGoDAwo9NfN+cc^v zd##_GggCIovM3TJ*D7bGtf=E6@bIL1>au%7}5P#V%qqn~WTns3p zTBWT9mjXl~hGs^1v5?RMH8LXq9zAf(rq-zg0Hphp70$NxSX7AU>u}Qm&ejA$yRyW= zxMYcIzFLswP8hzXo+}SLeHn#smwb;@t3Wua7nYEjMQWGG$j%>83mZPh^Wh@*(WP~~ zvU>DLXT5%NCS9sy@MeG;)@H0`%K!mb5og`2*pSc3=Me#G5{=kd<7v;Ebrm)%R8SLJ zNG1ZW2X)|eucGlW*!kRI7pARxKtY1BITl#aPzlg`fV?6D1$`t&9fA!N)kC7&;Ddm7 zr9mQlhnr>HEINvSJHMAns#gc}#~W?wtTuP@-eIk6Wc|m+RJynZg1`}A{vVVTsI4#H zLqa2+_feABWNm8VnI1SAAExyRv=tyFWDz`(Nz2MwJwl7+c|v1DCGA>r>I<>1D1^d9 z+7^Y#2^r;{nXpHfPj1 zr)_-dgWrUb!l!;9iA34}Ahko?BBl4d;=p+6JxNZ8V}(OKL^OAsysvVoFI~~`Kgpr4 z+f5GjrA-d?rMIn0uvrT~v$ur<8+?4JwkFq>x=*`soj!}`i?mU^UG>)-g;91_Ncr0?)fxSP7V7A+oJB?|`}4xNh(9lI;e=8| z8k3Ay-l6!jX!#H z`ioBWmp`LNuQ?uttSa>7vmlB%EolHx(3@VUx9-$dbk$