From 3f4b2af0ba4d8d266367f3c9a15011177fe42bd8 Mon Sep 17 00:00:00 2001 From: Nick Fitzgerald Date: Fri, 12 Jun 2026 15:21:47 -0700 Subject: [PATCH] Introduce helper methods for loading from `VMContext` These helpers always use the correct flags and region. Eventually there will be helper methods for all our other `VM*` types as well. Ideally we would mechanically generate all this stuff, and the `VM*` type definitions, and the offset calculation from the same single source of truth via fancy macros or whatever. Haven't fully thought through that yet, but one day. In the meantime, this prevents accidental bugs due to using incorrect flags and regions. --- crates/cranelift/src/alias_region.rs | 785 ++++++++++++++++++ crates/cranelift/src/alias_region_key.rs | 183 ---- crates/cranelift/src/compiler.rs | 224 +++-- crates/cranelift/src/compiler/component.rs | 134 +-- crates/cranelift/src/func_environ.rs | 324 +++----- crates/cranelift/src/func_environ/gc.rs | 7 +- .../cranelift/src/func_environ/gc/copying.rs | 40 +- crates/cranelift/src/func_environ/gc/drc.rs | 18 +- crates/cranelift/src/func_environ/gc/null.rs | 21 +- .../stack_switching/instructions.rs | 63 +- crates/cranelift/src/lib.rs | 2 +- crates/cranelift/src/trap.rs | 13 +- .../src/component/vmcomponent_offsets.rs | 10 + crates/environ/src/vmoffsets.rs | 30 + tests/disas/aarch64-entry-trampoline.wat | 2 +- tests/disas/alias-region-globals.wat | 2 +- tests/disas/alias-region-memories.wat | 2 +- tests/disas/alias-region-tables.wat | 2 +- tests/disas/arith.wat | 2 +- tests/disas/array-copy-anyref.wat | 2 +- tests/disas/array-copy-i64.wat | 2 +- tests/disas/array-copy-i8.wat | 2 +- tests/disas/array-copy-inline.wat | 2 +- tests/disas/array-fill-anyref.wat | 6 +- tests/disas/array-fill-externref.wat | 4 +- tests/disas/array-fill-f32.wat | 6 +- tests/disas/array-fill-f64.wat | 6 +- tests/disas/array-fill-funcref.wat | 8 +- tests/disas/array-fill-i16.wat | 8 +- tests/disas/array-fill-i31ref.wat | 6 +- tests/disas/array-fill-i32.wat | 8 +- tests/disas/array-fill-i64.wat | 8 +- tests/disas/basic-wat-test.wat | 2 +- tests/disas/bounds-check.wat | 2 +- tests/disas/br_table.wat | 8 +- tests/disas/branch-hinting-disabled.wat | 4 +- tests/disas/branch-hinting.wat | 10 +- tests/disas/byteswap.wat | 4 +- tests/disas/call-indirect-with-gc.wat | 2 +- tests/disas/call-indirect-without-gc.wat | 2 +- tests/disas/call-indirect.wat | 2 +- tests/disas/call-simd.wat | 4 +- tests/disas/call.wat | 4 +- .../checked-intrinsics-inlined-no-spectre.wat | 35 +- .../checked-intrinsics-inlined.wat | 41 +- .../direct-adapter-calls-inlining.wat | 83 +- .../component-model/direct-adapter-calls.wat | 67 +- ...xported-module-makes-adapters-indirect.wat | 11 +- .../inlining-and-unsafe-intrinsics.wat | 15 +- tests/disas/component-model/inlining-bug.wat | 24 +- .../component-model/inlining-fuzz-bug.wat | 24 +- tests/disas/component-model/issue-11458.wat | 15 +- ...instantiations-makes-adapters-indirect.wat | 11 +- tests/disas/conditional-traps.wat | 4 +- tests/disas/dead-code.wat | 8 +- tests/disas/debug-exceptions.wat | 176 ++-- tests/disas/debug.wat | 178 ++-- tests/disas/duplicate-function-types.wat | 2 +- .../disas/duplicate-loads-dynamic-memory.wat | 4 +- tests/disas/duplicate-loads-static-memory.wat | 4 +- ...re-access-same-index-different-offsets.wat | 4 +- ...re-access-same-index-different-offsets.wat | 4 +- tests/disas/epoch-interruption.wat | 2 +- tests/disas/exceptions.wat | 4 +- tests/disas/f32-load.wat | 2 +- tests/disas/f32-store.wat | 2 +- tests/disas/f64-load.wat | 2 +- tests/disas/f64-store.wat | 2 +- tests/disas/fac-multi-value.wat | 6 +- tests/disas/fibonacci.wat | 2 +- tests/disas/fixed-size-memory.wat | 4 +- tests/disas/foo.wat | 2 +- tests/disas/gc/array-copy-with-fuel.wat | 2 +- tests/disas/gc/array-fill-i8.wat | 2 +- tests/disas/gc/array-init-data.wat | 2 +- tests/disas/gc/array-new-data.wat | 4 +- tests/disas/gc/array-new-default-anyref.wat | 4 +- tests/disas/gc/array-new-default-exnref.wat | 4 +- .../disas/gc/array-new-default-externref.wat | 4 +- tests/disas/gc/array-new-default-f32.wat | 4 +- tests/disas/gc/array-new-default-f64.wat | 4 +- tests/disas/gc/array-new-default-funcref.wat | 4 +- tests/disas/gc/array-new-default-i16.wat | 4 +- tests/disas/gc/array-new-default-i32.wat | 4 +- tests/disas/gc/array-new-default-i64.wat | 4 +- tests/disas/gc/array-new-default-i8.wat | 4 +- tests/disas/gc/call-indirect-final-type.wat | 4 +- tests/disas/gc/copying/array-fill.wat | 2 +- tests/disas/gc/copying/array-get-s.wat | 2 +- tests/disas/gc/copying/array-get-u.wat | 2 +- tests/disas/gc/copying/array-get.wat | 2 +- tests/disas/gc/copying/array-len.wat | 2 +- .../gc/copying/array-new-fixed-of-gc-refs.wat | 4 +- tests/disas/gc/copying/array-new-fixed.wat | 4 +- tests/disas/gc/copying/array-new.wat | 4 +- tests/disas/gc/copying/array-set.wat | 2 +- tests/disas/gc/copying/br-on-cast-fail.wat | 22 +- tests/disas/gc/copying/br-on-cast.wat | 22 +- .../copying/call-indirect-and-subtyping.wat | 2 +- tests/disas/gc/copying/externref-globals.wat | 4 +- .../gc/copying/funcref-in-gc-heap-get.wat | 2 +- .../gc/copying/funcref-in-gc-heap-new.wat | 4 +- .../gc/copying/funcref-in-gc-heap-set.wat | 2 +- tests/disas/gc/copying/i31ref-globals.wat | 4 +- tests/disas/gc/copying/multiple-array-get.wat | 2 +- .../disas/gc/copying/multiple-struct-get.wat | 2 +- tests/disas/gc/copying/ref-cast.wat | 2 +- tests/disas/gc/copying/ref-is-null.wat | 4 +- tests/disas/gc/copying/ref-test-any.wat | 4 +- tests/disas/gc/copying/ref-test-array.wat | 2 +- .../copying/ref-test-concrete-func-type.wat | 2 +- .../gc/copying/ref-test-concrete-type.wat | 2 +- tests/disas/gc/copying/ref-test-eq.wat | 2 +- tests/disas/gc/copying/ref-test-i31.wat | 2 +- tests/disas/gc/copying/ref-test-none.wat | 4 +- tests/disas/gc/copying/ref-test-struct.wat | 2 +- tests/disas/gc/copying/struct-get.wat | 8 +- tests/disas/gc/copying/struct-new-default.wat | 4 +- tests/disas/gc/copying/struct-new.wat | 4 +- tests/disas/gc/copying/struct-set.wat | 6 +- tests/disas/gc/copying/v128-fields.wat | 2 +- tests/disas/gc/drc/array-fill.wat | 2 +- tests/disas/gc/drc/array-get-s.wat | 2 +- tests/disas/gc/drc/array-get-u.wat | 2 +- tests/disas/gc/drc/array-get.wat | 2 +- tests/disas/gc/drc/array-len.wat | 2 +- .../gc/drc/array-new-fixed-of-gc-refs.wat | 2 +- tests/disas/gc/drc/array-new-fixed.wat | 2 +- tests/disas/gc/drc/array-new.wat | 2 +- tests/disas/gc/drc/array-set.wat | 2 +- tests/disas/gc/drc/br-on-cast-fail.wat | 22 +- tests/disas/gc/drc/br-on-cast.wat | 22 +- .../gc/drc/call-indirect-and-subtyping.wat | 2 +- tests/disas/gc/drc/externref-globals.wat | 68 +- tests/disas/gc/drc/funcref-in-gc-heap-get.wat | 2 +- tests/disas/gc/drc/funcref-in-gc-heap-new.wat | 2 +- tests/disas/gc/drc/funcref-in-gc-heap-set.wat | 2 +- tests/disas/gc/drc/i31ref-globals.wat | 4 +- tests/disas/gc/drc/multiple-array-get.wat | 2 +- tests/disas/gc/drc/multiple-struct-get.wat | 2 +- tests/disas/gc/drc/ref-cast.wat | 2 +- tests/disas/gc/drc/ref-is-null.wat | 4 +- tests/disas/gc/drc/ref-test-any.wat | 4 +- tests/disas/gc/drc/ref-test-array.wat | 2 +- .../gc/drc/ref-test-concrete-func-type.wat | 2 +- tests/disas/gc/drc/ref-test-concrete-type.wat | 2 +- tests/disas/gc/drc/ref-test-eq.wat | 2 +- tests/disas/gc/drc/ref-test-i31.wat | 2 +- tests/disas/gc/drc/ref-test-none.wat | 4 +- tests/disas/gc/drc/ref-test-struct.wat | 2 +- tests/disas/gc/drc/struct-get.wat | 72 +- tests/disas/gc/drc/struct-new-default.wat | 2 +- tests/disas/gc/drc/struct-new.wat | 2 +- tests/disas/gc/drc/struct-set.wat | 6 +- tests/disas/gc/null/array-fill.wat | 2 +- tests/disas/gc/null/array-get-s.wat | 2 +- tests/disas/gc/null/array-get-u.wat | 2 +- tests/disas/gc/null/array-get.wat | 2 +- tests/disas/gc/null/array-len.wat | 2 +- .../gc/null/array-new-fixed-of-gc-refs.wat | 4 +- tests/disas/gc/null/array-new-fixed.wat | 4 +- tests/disas/gc/null/array-new.wat | 4 +- tests/disas/gc/null/array-set.wat | 2 +- tests/disas/gc/null/br-on-cast-fail.wat | 22 +- tests/disas/gc/null/br-on-cast.wat | 22 +- .../gc/null/call-indirect-and-subtyping.wat | 2 +- tests/disas/gc/null/externref-globals.wat | 4 +- .../disas/gc/null/funcref-in-gc-heap-get.wat | 2 +- .../disas/gc/null/funcref-in-gc-heap-new.wat | 4 +- .../disas/gc/null/funcref-in-gc-heap-set.wat | 2 +- tests/disas/gc/null/i31ref-globals.wat | 4 +- tests/disas/gc/null/multiple-array-get.wat | 2 +- tests/disas/gc/null/multiple-struct-get.wat | 2 +- tests/disas/gc/null/ref-cast.wat | 2 +- tests/disas/gc/null/ref-is-null.wat | 4 +- tests/disas/gc/null/ref-test-any.wat | 4 +- tests/disas/gc/null/ref-test-array.wat | 2 +- .../gc/null/ref-test-concrete-func-type.wat | 2 +- .../disas/gc/null/ref-test-concrete-type.wat | 2 +- tests/disas/gc/null/ref-test-eq.wat | 2 +- tests/disas/gc/null/ref-test-i31.wat | 2 +- tests/disas/gc/null/ref-test-none.wat | 4 +- tests/disas/gc/null/ref-test-struct.wat | 2 +- .../disas/gc/null/struct-get-guard-pages.wat | 8 +- .../gc/null/struct-get-no-guard-pages.wat | 8 +- tests/disas/gc/null/struct-get.wat | 8 +- tests/disas/gc/null/struct-new-default.wat | 4 +- tests/disas/gc/null/struct-new.wat | 4 +- tests/disas/gc/null/struct-set.wat | 6 +- tests/disas/gc/null/v128-fields.wat | 2 +- tests/disas/gc/ref-test-cast-final-type.wat | 4 +- tests/disas/gc/struct-new-default.wat | 4 +- tests/disas/gc/struct-new.wat | 4 +- .../disas/gc/typed-select-and-stack-maps.wat | 36 +- tests/disas/global-get.wat | 8 +- tests/disas/globals.wat | 2 +- tests/disas/i128-cmp.wat | 16 +- tests/disas/i32-load.wat | 2 +- tests/disas/i32-load16-s.wat | 2 +- tests/disas/i32-load16-u.wat | 2 +- tests/disas/i32-load8-s.wat | 2 +- tests/disas/i32-load8-u.wat | 2 +- tests/disas/i32-store.wat | 2 +- tests/disas/i32-store16.wat | 2 +- tests/disas/i32-store8.wat | 2 +- tests/disas/i64-load.wat | 2 +- tests/disas/i64-load16-s.wat | 2 +- tests/disas/i64-load16-u.wat | 2 +- tests/disas/i64-load8-s.wat | 2 +- tests/disas/i64-load8-u.wat | 2 +- tests/disas/i64-store.wat | 2 +- tests/disas/i64-store16.wat | 2 +- tests/disas/i64-store32.wat | 2 +- tests/disas/i64-store8.wat | 2 +- tests/disas/icall-loop.wat | 4 +- tests/disas/icall-simd.wat | 2 +- tests/disas/icall.wat | 2 +- tests/disas/idempotent-store.wat | 2 +- tests/disas/if-reachability-translation-0.wat | 2 +- tests/disas/if-reachability-translation-1.wat | 2 +- tests/disas/if-reachability-translation-2.wat | 2 +- tests/disas/if-reachability-translation-3.wat | 2 +- tests/disas/if-reachability-translation-4.wat | 2 +- tests/disas/if-reachability-translation-5.wat | 2 +- tests/disas/if-reachability-translation-6.wat | 2 +- tests/disas/if-unreachable-else-params-2.wat | 2 +- tests/disas/if-unreachable-else-params.wat | 2 +- tests/disas/indirect-call-no-caching.wat | 8 +- tests/disas/intra-module-inlining.wat | 6 +- tests/disas/issue-10929-v128-icmp-egraphs.wat | 2 +- tests/disas/issue-12808.wat | 16 +- tests/disas/issue-5696.wat | 2 +- ...0_guard_no_spectre_i32_access_0_offset.wat | 4 +- ...rd_no_spectre_i32_access_0x1000_offset.wat | 4 +- ...o_spectre_i32_access_0xffff0000_offset.wat | 4 +- ..._0_guard_no_spectre_i8_access_0_offset.wat | 4 +- ...ard_no_spectre_i8_access_0x1000_offset.wat | 4 +- ...no_spectre_i8_access_0xffff0000_offset.wat | 4 +- ..._guard_yes_spectre_i32_access_0_offset.wat | 4 +- ...d_yes_spectre_i32_access_0x1000_offset.wat | 4 +- ...s_spectre_i32_access_0xffff0000_offset.wat | 4 +- ...0_guard_yes_spectre_i8_access_0_offset.wat | 4 +- ...rd_yes_spectre_i8_access_0x1000_offset.wat | 4 +- ...es_spectre_i8_access_0xffff0000_offset.wat | 4 +- ...f_guard_no_spectre_i32_access_0_offset.wat | 4 +- ...rd_no_spectre_i32_access_0x1000_offset.wat | 4 +- ...o_spectre_i32_access_0xffff0000_offset.wat | 4 +- ...ff_guard_no_spectre_i8_access_0_offset.wat | 4 +- ...ard_no_spectre_i8_access_0x1000_offset.wat | 4 +- ...no_spectre_i8_access_0xffff0000_offset.wat | 4 +- ..._guard_yes_spectre_i32_access_0_offset.wat | 4 +- ...d_yes_spectre_i32_access_0x1000_offset.wat | 4 +- ...s_spectre_i32_access_0xffff0000_offset.wat | 4 +- ...f_guard_yes_spectre_i8_access_0_offset.wat | 4 +- ...rd_yes_spectre_i8_access_0x1000_offset.wat | 4 +- ...es_spectre_i8_access_0xffff0000_offset.wat | 4 +- ...0_guard_no_spectre_i32_access_0_offset.wat | 4 +- ...rd_no_spectre_i32_access_0x1000_offset.wat | 4 +- ...o_spectre_i32_access_0xffff0000_offset.wat | 4 +- ..._0_guard_no_spectre_i8_access_0_offset.wat | 4 +- ...ard_no_spectre_i8_access_0x1000_offset.wat | 4 +- ...no_spectre_i8_access_0xffff0000_offset.wat | 4 +- ..._guard_yes_spectre_i32_access_0_offset.wat | 4 +- ...d_yes_spectre_i32_access_0x1000_offset.wat | 4 +- ...s_spectre_i32_access_0xffff0000_offset.wat | 4 +- ...0_guard_yes_spectre_i8_access_0_offset.wat | 4 +- ...rd_yes_spectre_i8_access_0x1000_offset.wat | 4 +- ...es_spectre_i8_access_0xffff0000_offset.wat | 4 +- ...f_guard_no_spectre_i32_access_0_offset.wat | 4 +- ...rd_no_spectre_i32_access_0x1000_offset.wat | 4 +- ...o_spectre_i32_access_0xffff0000_offset.wat | 4 +- ...ff_guard_no_spectre_i8_access_0_offset.wat | 4 +- ...ard_no_spectre_i8_access_0x1000_offset.wat | 4 +- ...no_spectre_i8_access_0xffff0000_offset.wat | 4 +- ..._guard_yes_spectre_i32_access_0_offset.wat | 4 +- ...d_yes_spectre_i32_access_0x1000_offset.wat | 4 +- ...s_spectre_i32_access_0xffff0000_offset.wat | 4 +- ...f_guard_yes_spectre_i8_access_0_offset.wat | 4 +- ...rd_yes_spectre_i8_access_0x1000_offset.wat | 4 +- ...es_spectre_i8_access_0xffff0000_offset.wat | 4 +- ...0_guard_no_spectre_i32_access_0_offset.wat | 4 +- ...rd_no_spectre_i32_access_0x1000_offset.wat | 4 +- ...o_spectre_i32_access_0xffff0000_offset.wat | 4 +- ..._0_guard_no_spectre_i8_access_0_offset.wat | 4 +- ...ard_no_spectre_i8_access_0x1000_offset.wat | 4 +- ...no_spectre_i8_access_0xffff0000_offset.wat | 4 +- ..._guard_yes_spectre_i32_access_0_offset.wat | 4 +- ...d_yes_spectre_i32_access_0x1000_offset.wat | 4 +- ...s_spectre_i32_access_0xffff0000_offset.wat | 4 +- ...0_guard_yes_spectre_i8_access_0_offset.wat | 4 +- ...rd_yes_spectre_i8_access_0x1000_offset.wat | 4 +- ...es_spectre_i8_access_0xffff0000_offset.wat | 4 +- ...f_guard_no_spectre_i32_access_0_offset.wat | 4 +- ...rd_no_spectre_i32_access_0x1000_offset.wat | 4 +- ...o_spectre_i32_access_0xffff0000_offset.wat | 4 +- ...ff_guard_no_spectre_i8_access_0_offset.wat | 4 +- ...ard_no_spectre_i8_access_0x1000_offset.wat | 4 +- ...no_spectre_i8_access_0xffff0000_offset.wat | 4 +- ..._guard_yes_spectre_i32_access_0_offset.wat | 4 +- ...d_yes_spectre_i32_access_0x1000_offset.wat | 4 +- ...s_spectre_i32_access_0xffff0000_offset.wat | 4 +- ...f_guard_yes_spectre_i8_access_0_offset.wat | 4 +- ...rd_yes_spectre_i8_access_0x1000_offset.wat | 4 +- ...es_spectre_i8_access_0xffff0000_offset.wat | 4 +- ...0_guard_no_spectre_i32_access_0_offset.wat | 4 +- ...rd_no_spectre_i32_access_0x1000_offset.wat | 4 +- ...o_spectre_i32_access_0xffff0000_offset.wat | 4 +- ..._0_guard_no_spectre_i8_access_0_offset.wat | 4 +- ...ard_no_spectre_i8_access_0x1000_offset.wat | 4 +- ...no_spectre_i8_access_0xffff0000_offset.wat | 4 +- ..._guard_yes_spectre_i32_access_0_offset.wat | 4 +- ...d_yes_spectre_i32_access_0x1000_offset.wat | 4 +- ...s_spectre_i32_access_0xffff0000_offset.wat | 4 +- ...0_guard_yes_spectre_i8_access_0_offset.wat | 4 +- ...rd_yes_spectre_i8_access_0x1000_offset.wat | 4 +- ...es_spectre_i8_access_0xffff0000_offset.wat | 4 +- ...f_guard_no_spectre_i32_access_0_offset.wat | 4 +- ...rd_no_spectre_i32_access_0x1000_offset.wat | 4 +- ...o_spectre_i32_access_0xffff0000_offset.wat | 4 +- ...ff_guard_no_spectre_i8_access_0_offset.wat | 4 +- ...ard_no_spectre_i8_access_0x1000_offset.wat | 4 +- ...no_spectre_i8_access_0xffff0000_offset.wat | 4 +- ..._guard_yes_spectre_i32_access_0_offset.wat | 4 +- ...d_yes_spectre_i32_access_0x1000_offset.wat | 4 +- ...s_spectre_i32_access_0xffff0000_offset.wat | 4 +- ...f_guard_yes_spectre_i8_access_0_offset.wat | 4 +- ...rd_yes_spectre_i8_access_0x1000_offset.wat | 4 +- ...es_spectre_i8_access_0xffff0000_offset.wat | 4 +- tests/disas/memory-copy-epochs.wat | 2 +- tests/disas/memory-copy-fuel.wat | 2 +- tests/disas/memory-copy-inline.wat | 2 +- tests/disas/memory-min-max-same.wat | 42 +- tests/disas/memory.wat | 2 +- tests/disas/memory_copy_host64.wat | 12 +- tests/disas/memory_fill_host64.wat | 10 +- tests/disas/metadata-for-internal-asserts.wat | 4 +- tests/disas/multi-0.wat | 2 +- tests/disas/multi-1.wat | 2 +- tests/disas/multi-10.wat | 2 +- tests/disas/multi-11.wat | 2 +- tests/disas/multi-12.wat | 2 +- tests/disas/multi-13.wat | 2 +- tests/disas/multi-14.wat | 2 +- tests/disas/multi-15.wat | 2 +- tests/disas/multi-16.wat | 2 +- tests/disas/multi-17.wat | 2 +- tests/disas/multi-2.wat | 2 +- tests/disas/multi-3.wat | 2 +- tests/disas/multi-4.wat | 2 +- tests/disas/multi-5.wat | 2 +- tests/disas/multi-6.wat | 2 +- tests/disas/multi-7.wat | 2 +- tests/disas/multi-8.wat | 2 +- tests/disas/multi-9.wat | 2 +- tests/disas/non-fixed-size-memory.wat | 4 +- tests/disas/nullref.wat | 4 +- tests/disas/passive-data.wat | 4 +- tests/disas/pic.wat | 20 +- tests/disas/pr2303.wat | 2 +- tests/disas/pr2559.wat | 4 +- tests/disas/pulley-entry-trampoline.wat | 2 +- tests/disas/readonly-funcrefs.wat | 4 +- tests/disas/readonly-heap-base-pointer1.wat | 2 +- tests/disas/readonly-heap-base-pointer2.wat | 2 +- tests/disas/readonly-heap-base-pointer3.wat | 2 +- tests/disas/ref-func-0.wat | 2 +- tests/disas/riscv64-component-builtins.wat | 4 +- tests/disas/riscv64-entry-trampoline.wat | 2 +- tests/disas/s390x-entry-trampoline.wat | 2 +- tests/disas/select.wat | 6 +- tests/disas/simd-store.wat | 68 +- tests/disas/simd.wat | 8 +- tests/disas/simple.wat | 6 +- .../resume-suspend-data-passing.wat | 41 +- .../disas/stack-switching/resume-suspend.wat | 41 +- .../stack-switching/symmetric-switch.wat | 22 +- tests/disas/startup-data-active.wat | 2 +- tests/disas/startup-elem-active.wat | 2 +- tests/disas/startup-global.wat | 2 +- tests/disas/startup-passive-segment.wat | 2 +- tests/disas/startup-start.wat | 2 +- tests/disas/startup-table-initial-value.wat | 2 +- tests/disas/sub-global.wat | 2 +- tests/disas/table-copy.wat | 10 +- tests/disas/table-get-fixed-size.wat | 4 +- tests/disas/table-get.wat | 4 +- tests/disas/table-set-fixed-size.wat | 4 +- tests/disas/table-set.wat | 4 +- tests/disas/typed-funcrefs-eager-init.wat | 8 +- tests/disas/typed-funcrefs.wat | 8 +- tests/disas/unreachable_code.wat | 8 +- tests/disas/winch/x64/load/grow_load.wat | 2 +- .../disas/winch/x64/table/init_copy_drop.wat | 12 +- tests/disas/x64-entry-trampoline.wat | 2 +- tests/disas/x64-simd-round-without-sse41.wat | 18 +- 395 files changed, 2400 insertions(+), 1934 deletions(-) create mode 100644 crates/cranelift/src/alias_region.rs delete mode 100644 crates/cranelift/src/alias_region_key.rs diff --git a/crates/cranelift/src/alias_region.rs b/crates/cranelift/src/alias_region.rs new file mode 100644 index 000000000000..8811fa2be0cf --- /dev/null +++ b/crates/cranelift/src/alias_region.rs @@ -0,0 +1,785 @@ +use core::fmt; +use cranelift_codegen::{ + cursor::FuncCursor, + ir::{self, InstBuilder as _}, +}; +use wasmtime_environ::{ + DefinedGlobalIndex, DefinedMemoryIndex, DefinedTableIndex, FuncIndex, GetPtrSize, MemoryIndex, + PtrSize as _, RuntimeDataIndex, StaticModuleIndex, TableIndex, TagIndex, VMOffsets, +}; + +#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)] +enum VmType { + VMContext, + VMStoreContext, + + #[allow( + dead_code, + reason = "used when tagging `VMMemoryDefinition` fields in upcoming commits" + )] + VMMemoryDefinition, +} + +/// A key that uniquely identifies an alias region across an entire compilation. +/// +/// This is used to assign stable `user_id`s to `AliasRegionData` entries so +/// that alias regions can be deduplicated during inlining. +/// +/// The key encodes into a single `u32` with the following layout: +/// `[ kind: 4 bits | data: 28 bits ]` +#[derive(Clone, Copy, PartialEq, Eq, Hash)] +enum AliasRegionKey { + /// An access of a field within a VM data structure of type `ty`. + Vm { + /// The type of VM data structure being accessed. + ty: VmType, + /// The offset of the accessed field *within* the `ty` structure (or + /// the base offset of the array, for array fields). + offset: u32, + }, + + /// An imported or exported memory access (shared across all + /// imported/exported memories). + PublicMemory, + + /// A defined memory access. + DefinedMemory { + /// The static module index. + module: StaticModuleIndex, + /// The defined memory index within the module. + index: DefinedMemoryIndex, + }, + + /// An imported or exported table access (shared across all + /// imported/exported tables). + PublicTable, + + /// A defined table access. + DefinedTable { + /// The static module index. + module: StaticModuleIndex, + /// The defined table index within the module. + index: DefinedTableIndex, + }, + + /// An imported or exported global access (shared across all + /// imported/exported globals). + PublicGlobal, + + /// A defined global access. + DefinedGlobal { + /// The static module index. + module: StaticModuleIndex, + /// The defined global index within the module. + index: DefinedGlobalIndex, + }, + + /// A GC heap access. + GcHeap, +} + +impl AliasRegionKey { + const KIND_BITS: u32 = 4; + const KIND_OFFSET: u32 = 32 - Self::KIND_BITS; + const KIND_MASK: u32 = ((1 << Self::KIND_BITS) - 1) << Self::KIND_OFFSET; + + const OFFSET_MASK: u32 = !Self::KIND_MASK; + + const MODULE_BITS: u32 = 8; + const MODULE_OFFSET: u32 = Self::KIND_OFFSET - Self::MODULE_BITS; + const MODULE_MASK: u32 = ((1 << Self::MODULE_BITS) - 1) << Self::MODULE_OFFSET; + + const INDEX_MASK: u32 = !Self::KIND_MASK & !Self::MODULE_MASK; + + const fn new_kind(kind: u32) -> u32 { + assert!(kind < (1 << Self::KIND_BITS)); + kind << Self::KIND_OFFSET + } + + const VM_CONTEXT_KIND: u32 = Self::new_kind(0b0000); + const VM_STORE_CONTEXT_KIND: u32 = Self::new_kind(0b0001); + const IMPORTED_MEMORY_KIND: u32 = Self::new_kind(0b0010); + const DEFINED_MEMORY_KIND: u32 = Self::new_kind(0b0011); + const IMPORTED_TABLE_KIND: u32 = Self::new_kind(0b0100); + const DEFINED_TABLE_KIND: u32 = Self::new_kind(0b0101); + const IMPORTED_GLOBAL_KIND: u32 = Self::new_kind(0b0110); + const DEFINED_GLOBAL_KIND: u32 = Self::new_kind(0b0111); + const GC_HEAP_KIND: u32 = Self::new_kind(0b1000); + const VM_MEMORY_DEFINITION_KIND: u32 = Self::new_kind(0b1001); + + /// Encode this key into a raw `u32` suitable for use as an + /// `AliasRegionData::user_id`. + pub(crate) fn into_raw(self) -> u32 { + match self { + AliasRegionKey::Vm { ty, offset } => { + debug_assert_eq!(offset & Self::KIND_MASK, 0); + let kind = match ty { + VmType::VMContext => Self::VM_CONTEXT_KIND, + VmType::VMStoreContext => Self::VM_STORE_CONTEXT_KIND, + VmType::VMMemoryDefinition => Self::VM_MEMORY_DEFINITION_KIND, + }; + kind | (offset & Self::OFFSET_MASK) + } + AliasRegionKey::PublicMemory => Self::IMPORTED_MEMORY_KIND, + AliasRegionKey::DefinedMemory { module, index } => { + debug_assert_eq!( + module.as_u32() & !Self::MODULE_MASK >> Self::MODULE_OFFSET, + 0 + ); + debug_assert_eq!(index.as_u32() & !Self::INDEX_MASK, 0); + Self::DEFINED_MEMORY_KIND + | (module.as_u32() << Self::MODULE_OFFSET) + | index.as_u32() + } + AliasRegionKey::PublicTable => Self::IMPORTED_TABLE_KIND, + AliasRegionKey::DefinedTable { module, index } => { + debug_assert_eq!( + module.as_u32() & !Self::MODULE_MASK >> Self::MODULE_OFFSET, + 0 + ); + debug_assert_eq!(index.as_u32() & !Self::INDEX_MASK, 0); + Self::DEFINED_TABLE_KIND | (module.as_u32() << Self::MODULE_OFFSET) | index.as_u32() + } + AliasRegionKey::PublicGlobal => Self::IMPORTED_GLOBAL_KIND, + AliasRegionKey::DefinedGlobal { module, index } => { + debug_assert_eq!( + module.as_u32() & !Self::MODULE_MASK >> Self::MODULE_OFFSET, + 0 + ); + debug_assert_eq!(index.as_u32() & !Self::INDEX_MASK, 0); + Self::DEFINED_GLOBAL_KIND + | (module.as_u32() << Self::MODULE_OFFSET) + | index.as_u32() + } + AliasRegionKey::GcHeap => Self::GC_HEAP_KIND, + } + } +} + +impl fmt::Debug for AliasRegionKey { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + AliasRegionKey::Vm { ty, offset } => write!(f, "{ty:?}+{offset:#x}"), + AliasRegionKey::PublicMemory => write!(f, "PublicMemory"), + AliasRegionKey::DefinedMemory { module, index } => { + write!(f, "DefinedMemory({module:?}, {index:?})") + } + AliasRegionKey::PublicTable => write!(f, "PublicTable"), + AliasRegionKey::DefinedTable { module, index } => { + write!(f, "DefinedTable({module:?}, {index:?})") + } + AliasRegionKey::PublicGlobal => write!(f, "PublicGlobal"), + AliasRegionKey::DefinedGlobal { module, index } => { + write!(f, "DefinedGlobal({module:?}, {index:?})") + } + AliasRegionKey::GcHeap => write!(f, "GcHeap"), + } + } +} + +impl From for ir::AliasRegionData { + fn from(key: AliasRegionKey) -> ir::AliasRegionData { + ir::AliasRegionData { + user_id: key.into_raw(), + description: format!("{key:?}").into(), + } + } +} + +/// Alias region cache and load/store helper type. +pub struct AliasRegions { + pointer_type: ir::Type, + offsets: Offsets, + + /// Cached alias regions for alias analysis. + /// + /// Avoids allocating a string for the debug formatting of `AliasRegionKey` + /// as the `ir::AliasRegionData::description` string repeatedly. + cache: std::collections::HashMap, +} + +impl AliasRegions +where + Offsets: GetPtrSize, +{ + /// Create a new `AliasRegions`. + pub fn new(offsets: Offsets) -> Self { + Self { + pointer_type: ir::Type::int_with_byte_size(offsets.get_ptr_size().size().into()) + .unwrap(), + offsets, + cache: std::collections::HashMap::default(), + } + } + + /// Get the alias region for the given key. + fn region(&mut self, func: &mut ir::Function, key: AliasRegionKey) -> ir::AliasRegion { + *self + .cache + .entry(key) + .or_insert_with(|| func.dfg.alias_regions.insert(key.into())) + } + + /// Get the alias region for accesses into the GC heap. + pub fn gc_heap_region(&mut self, func: &mut ir::Function) -> ir::AliasRegion { + self.region(func, AliasRegionKey::GcHeap) + } + + /// Get the alias region for an imported or exported memory access (shared + /// across all imported/exported memories). + pub fn public_memory_region(&mut self, func: &mut ir::Function) -> ir::AliasRegion { + self.region(func, AliasRegionKey::PublicMemory) + } + + /// Get the alias region for accessing a defined memory that is not + /// exported. + pub fn defined_memory_region( + &mut self, + func: &mut ir::Function, + module: StaticModuleIndex, + index: DefinedMemoryIndex, + ) -> ir::AliasRegion { + self.region(func, AliasRegionKey::DefinedMemory { module, index }) + } + + /// Get the alias region for an imported or exported table access (shared + /// across all imported/exported memories). + pub fn public_table_region(&mut self, func: &mut ir::Function) -> ir::AliasRegion { + self.region(func, AliasRegionKey::PublicTable) + } + + /// Get the alias region for accessing a defined table that is not + /// exported. + pub fn defined_table_region( + &mut self, + func: &mut ir::Function, + module: StaticModuleIndex, + index: DefinedTableIndex, + ) -> ir::AliasRegion { + self.region(func, AliasRegionKey::DefinedTable { module, index }) + } + + /// Get the alias region for an imported or exported global access (shared + /// across all imported/exported memories). + pub fn public_global_region(&mut self, func: &mut ir::Function) -> ir::AliasRegion { + self.region(func, AliasRegionKey::PublicGlobal) + } + + /// Get the alias region for accessing a defined global that is not + /// exported. + pub fn defined_global_region( + &mut self, + func: &mut ir::Function, + module: StaticModuleIndex, + index: DefinedGlobalIndex, + ) -> ir::AliasRegion { + self.region(func, AliasRegionKey::DefinedGlobal { module, index }) + } +} + +/// `VMContext`-related methods that are valid for any `VMContext`, regardless +/// of its particular `VMOffsets`. +impl AliasRegions +where + Offsets: GetPtrSize, +{ + /// Get the alias region for the given offset into the `VMContext`. + fn vmctx_region(&mut self, func: &mut ir::Function, offset: u32) -> ir::AliasRegion { + self.region( + func, + AliasRegionKey::Vm { + ty: VmType::VMContext, + offset: offset.into(), + }, + ) + } + + /// Get the region for loading from a `*mut VMContext` at the given offset. + /// + /// XXX: This is ONLY for use with `ir::GlobalValue`s, all other uses should + /// instead use a helper method that actually emits the full load + /// instruction instead (e.g. `AliasRegions::vmctx_store_context`). + pub fn vmctx_region_for_use_in_ir_global( + &mut self, + func: &mut ir::Function, + offset: u32, + ) -> ir::AliasRegion { + self.vmctx_region(func, offset) + } + + fn vmctx_load( + &mut self, + cursor: &mut FuncCursor<'_>, + ty: ir::Type, + base_flags: ir::MemFlagsData, + vmctx: ir::Value, + offset: u32, + ) -> ir::Value { + let region = self.vmctx_region(cursor.func, offset); + cursor.ins().load( + ty, + base_flags.with_alias_region(Some(region)), + vmctx, + i32::try_from(offset).unwrap(), + ) + } + + fn vmctx_store( + &mut self, + cursor: &mut FuncCursor<'_>, + base_flags: ir::MemFlagsData, + vmctx: ir::Value, + offset: u32, + val: ir::Value, + ) { + let region = self.vmctx_region(cursor.func, offset); + cursor.ins().store( + base_flags.with_alias_region(Some(region)), + val, + vmctx, + i32::try_from(offset).unwrap(), + ); + } + + /// Load the `VMContext::magic` field. + pub fn vmctx_magic(&mut self, cursor: &mut FuncCursor<'_>, vmctx: ir::Value) -> ir::Value { + self.vmctx_load( + cursor, + ir::types::I32, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + self.offsets.get_ptr_size().vmctx_magic().into(), + ) + } + + /// Load the `*mut VMStoreContext` value out of the given `*mut VMContext`. + pub fn vmctx_store_context( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + ) -> ir::Value { + self.vmctx_load( + cursor, + self.pointer_type, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + self.offsets.get_ptr_size().vmctx_store_context().into(), + ) + } + + /// Load the `*mut i64` epoch pointer out of the given `*mut VMContext`. + pub fn vmctx_epoch_ptr(&mut self, cursor: &mut FuncCursor<'_>, vmctx: ir::Value) -> ir::Value { + self.vmctx_load( + cursor, + self.pointer_type, + ir::MemFlagsData::trusted(), + vmctx, + self.offsets.get_ptr_size().vmctx_epoch_ptr().into(), + ) + } + + /// Load the base pointer of the `[VMSharedTypeIndex]` array out of the + /// given `*mut VMContext`. + pub fn vmctx_shared_type_ids_array( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + ) -> ir::Value { + self.vmctx_load( + cursor, + self.pointer_type, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + self.offsets.get_ptr_size().vmctx_type_ids_array().into(), + ) + } + + /// Load the collector's heap data pointer out of the `*mut VMContext`. + pub fn vmctx_gc_heap_data( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + ) -> ir::Value { + self.vmctx_load( + cursor, + self.pointer_type, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + self.offsets.get_ptr_size().vmctx_gc_heap_data().into(), + ) + } + + /// Load the base pointer to the builtin-functions array from a `*mut + /// VMContext`. + pub fn vmctx_builtin_functions( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + ) -> ir::Value { + self.vmctx_load( + cursor, + self.pointer_type, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + self.offsets + .get_ptr_size() + .vmcontext_builtin_functions() + .into(), + ) + } +} + +/// `VMContext`-related methods that are specific to a particular Wasm module's +/// `VMOffsets`. +impl AliasRegions> { + /// Load the imported tag's `VMTagImport::vmctx` field from the `*mut + /// VMContext`. + pub fn vmctx_vmtag_import_vmctx( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + tag: TagIndex, + ) -> ir::Value { + self.vmctx_load( + cursor, + self.pointer_type, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + self.offsets.vmctx_vmtag_import_vmctx(tag), + ) + } + + /// Load the imported tag's `VMTagImport::index` field from the `*mut + /// VMContext`. + pub fn vmctx_vmtag_import_index( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + tag: TagIndex, + ) -> ir::Value { + self.vmctx_load( + cursor, + ir::types::I32, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + self.offsets.vmctx_vmtag_import_index(tag), + ) + } + + /// Load the imported tag's `VMTagImport::from` field from the `*mut + /// VMContext`. + pub fn vmctx_vmtag_import_from( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + tag: TagIndex, + ) -> ir::Value { + self.vmctx_load( + cursor, + self.pointer_type, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + self.offsets.vmctx_vmtag_import_from(tag), + ) + } + + /// Load the import function's `VMFunctionImport::vmctx` field from the + /// `*mut VMContext`. + pub fn vmctx_vmfunction_import_vmctx( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + func: FuncIndex, + ) -> ir::Value { + self.vmctx_load( + cursor, + self.pointer_type, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + self.offsets.vmctx_vmfunction_import_vmctx(func), + ) + } + + /// Load the import function's `VMFunctionImport::wasm_call` field from the + /// `*mut VMContext`. + pub fn vmctx_vmfunction_import_wasm_call( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + func: FuncIndex, + ) -> ir::Value { + self.vmctx_load( + cursor, + self.pointer_type, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + self.offsets.vmctx_vmfunction_import_wasm_call(func), + ) + } + + /// Load the imported memory's `VMMemoryImport::vmctx` field from the `*mut + /// VMContext`. + pub fn vmctx_vmmemory_import_vmctx( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + memory: MemoryIndex, + ) -> ir::Value { + let mem_offset = self.offsets.vmctx_vmmemory_import(memory); + let mem_vmctx_offset = mem_offset + u32::from(self.offsets.vmmemory_import_vmctx()); + self.vmctx_load( + cursor, + self.pointer_type, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + mem_vmctx_offset, + ) + } + + /// Load the imported memory's `VMMemoryImport::index` field from the `*mut + /// VMContext`. + pub fn vmctx_vmmemory_import_index( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + memory: MemoryIndex, + ) -> ir::Value { + let mem_offset = self.offsets.vmctx_vmmemory_import(memory); + let mem_index_offset = mem_offset + u32::from(self.offsets.vmmemory_import_index()); + self.vmctx_load( + cursor, + ir::types::I32, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + mem_index_offset, + ) + } + + /// Load the imported memory's `VMMemoryImport::from` field from the `*mut + /// VMContext`. + pub fn vmctx_vmmemory_import_from( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + memory: MemoryIndex, + ) -> ir::Value { + let mem_offset = self.offsets.vmctx_vmmemory_import(memory); + let mem_index_offset = mem_offset + u32::from(self.offsets.vmmemory_import_from()); + self.vmctx_load( + cursor, + ir::types::I32, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + mem_index_offset, + ) + } + + /// Load the imported table's `VMTableImport::vmctx` field from the `*mut + /// VMContext`. + pub fn vmctx_vmtable_import_vmctx( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + table: TableIndex, + ) -> ir::Value { + let table_offset = self.offsets.vmctx_vmtable_import(table); + let table_vmctx_offset = table_offset + u32::from(self.offsets.vmtable_import_vmctx()); + self.vmctx_load( + cursor, + self.pointer_type, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + table_vmctx_offset, + ) + } + + /// Load the imported table's `VMTableImport::index` field from the `*mut + /// VMContext`. + pub fn vmctx_vmtable_import_index( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + table: TableIndex, + ) -> ir::Value { + let table_offset = self.offsets.vmctx_vmtable_import(table); + let table_index_offset = table_offset + u32::from(self.offsets.vmtable_import_index()); + self.vmctx_load( + cursor, + ir::types::I32, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + table_index_offset, + ) + } + + /// Load the defined memory's `*mut VMMemoryDefinition` out of the `*mut + /// VMContext`. + pub fn vmctx_vmmemory_pointer( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + memory: DefinedMemoryIndex, + ) -> ir::Value { + self.vmctx_load( + cursor, + self.pointer_type, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + self.offsets.vmctx_vmmemory_pointer(memory), + ) + } + + /// Load the base of the given runtime data out of the `*mut VMContext`. + pub fn vmctx_runtime_data_base( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + runtime_data: RuntimeDataIndex, + ) -> ir::Value { + self.vmctx_load( + cursor, + self.pointer_type, + ir::MemFlagsData::trusted(), + vmctx, + self.offsets.vmctx_runtime_data_base(runtime_data), + ) + } + + /// Load the length of the given runtime data out of the `*mut VMContext`. + pub fn vmctx_runtime_data_length( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + runtime_data: RuntimeDataIndex, + ) -> ir::Value { + self.vmctx_load( + cursor, + ir::types::I32, + ir::MemFlagsData::trusted(), + vmctx, + self.offsets.vmctx_runtime_data_length(runtime_data), + ) + } + + /// Load the length of the given runtime data out of the `*mut VMContext`. + pub fn store_vmctx_runtime_data_length( + &mut self, + cursor: &mut FuncCursor<'_>, + vmctx: ir::Value, + runtime_data: RuntimeDataIndex, + new_length: ir::Value, + ) { + self.vmctx_store( + cursor, + ir::MemFlagsData::trusted(), + vmctx, + self.offsets.vmctx_runtime_data_length(runtime_data), + new_length, + ) + } +} + +/// `VMStoreContext`-related methods. +impl AliasRegions +where + Offsets: GetPtrSize, +{ + fn vmstore_context_region(&mut self, func: &mut ir::Function, offset: u32) -> ir::AliasRegion { + self.region( + func, + AliasRegionKey::Vm { + ty: VmType::VMStoreContext, + offset: offset.into(), + }, + ) + } + + fn vmstore_context_load( + &mut self, + cursor: &mut FuncCursor<'_>, + ty: ir::Type, + base_flags: ir::MemFlagsData, + vmstore_ctx: ir::Value, + offset: u32, + ) -> ir::Value { + let region = self.vmstore_context_region(cursor.func, offset); + cursor.ins().load( + ty, + base_flags.with_alias_region(Some(region)), + vmstore_ctx, + i32::try_from(offset).unwrap(), + ) + } + + fn vmstore_context_store( + &mut self, + cursor: &mut FuncCursor<'_>, + base_flags: ir::MemFlagsData, + vmstore_ctx: ir::Value, + offset: u32, + val: ir::Value, + ) { + let region = self.vmstore_context_region(cursor.func, offset); + cursor.ins().store( + base_flags.with_alias_region(Some(region)), + val, + vmstore_ctx, + i32::try_from(offset).unwrap(), + ); + } + + /// Load a pointer to the `*mut T` store data from a `*mut VMStoreContext`. + pub fn vmstore_context_store_data( + &mut self, + cursor: &mut FuncCursor<'_>, + vmstore_ctx: ir::Value, + ) -> ir::Value { + self.vmstore_context_load( + cursor, + self.pointer_type, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmstore_ctx, + self.offsets + .get_ptr_size() + .vmstore_context_store_data() + .into(), + ) + } + + /// Load the `VMStoreContext::execution_version` field. + pub fn vmstore_context_execution_version( + &mut self, + cursor: &mut FuncCursor<'_>, + vmstore_ctx: ir::Value, + ) -> ir::Value { + self.vmstore_context_load( + cursor, + ir::types::I64, + ir::MemFlagsData::trusted(), + vmstore_ctx, + self.offsets + .get_ptr_size() + .vmstore_context_execution_version() + .into(), + ) + } + + /// Store the `VMStoreContext::execution_version` field. + pub fn store_vmstore_context_execution_version( + &mut self, + cursor: &mut FuncCursor<'_>, + vmstore_ctx: ir::Value, + new_version: ir::Value, + ) { + self.vmstore_context_store( + cursor, + ir::MemFlagsData::trusted(), + vmstore_ctx, + self.offsets + .get_ptr_size() + .vmstore_context_execution_version() + .into(), + new_version, + ) + } +} diff --git a/crates/cranelift/src/alias_region_key.rs b/crates/cranelift/src/alias_region_key.rs deleted file mode 100644 index bcc56fcb3b14..000000000000 --- a/crates/cranelift/src/alias_region_key.rs +++ /dev/null @@ -1,183 +0,0 @@ -use core::fmt; -use cranelift_codegen::ir; -use wasmtime_environ::{ - DefinedGlobalIndex, DefinedMemoryIndex, DefinedTableIndex, StaticModuleIndex, -}; - -#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)] -pub(crate) enum VmType { - VMContext, - VMStoreContext, - - #[allow( - dead_code, - reason = "used when tagging `VMMemoryDefinition` fields in upcoming commits" - )] - VMMemoryDefinition, -} - -/// A key that uniquely identifies an alias region across an entire compilation. -/// -/// This is used to assign stable `user_id`s to `AliasRegionData` entries so -/// that alias regions can be deduplicated during inlining. -/// -/// The key encodes into a single `u32` with the following layout: -/// `[ kind: 4 bits | data: 28 bits ]` -#[derive(Clone, Copy, PartialEq, Eq, Hash)] -pub(crate) enum AliasRegionKey { - /// An access of a field within a VM data structure of type `ty`. - Vm { - /// The type of VM data structure being accessed. - ty: VmType, - /// The offset of the accessed field *within* the `ty` structure (or - /// the base offset of the array, for array fields). - offset: u32, - }, - - /// An imported or exported memory access (shared across all - /// imported/exported memories). - PublicMemory, - - /// A defined memory access. - DefinedMemory { - /// The static module index. - module: StaticModuleIndex, - /// The defined memory index within the module. - index: DefinedMemoryIndex, - }, - - /// An imported or exported table access (shared across all - /// imported/exported tables). - PublicTable, - - /// A defined table access. - DefinedTable { - /// The static module index. - module: StaticModuleIndex, - /// The defined table index within the module. - index: DefinedTableIndex, - }, - - /// An imported or exported global access (shared across all - /// imported/exported globals). - PublicGlobal, - - /// A defined global access. - DefinedGlobal { - /// The static module index. - module: StaticModuleIndex, - /// The defined global index within the module. - index: DefinedGlobalIndex, - }, - - /// A GC heap access. - GcHeap, -} - -impl AliasRegionKey { - const KIND_BITS: u32 = 4; - const KIND_OFFSET: u32 = 32 - Self::KIND_BITS; - const KIND_MASK: u32 = ((1 << Self::KIND_BITS) - 1) << Self::KIND_OFFSET; - - const OFFSET_MASK: u32 = !Self::KIND_MASK; - - const MODULE_BITS: u32 = 8; - const MODULE_OFFSET: u32 = Self::KIND_OFFSET - Self::MODULE_BITS; - const MODULE_MASK: u32 = ((1 << Self::MODULE_BITS) - 1) << Self::MODULE_OFFSET; - - const INDEX_MASK: u32 = !Self::KIND_MASK & !Self::MODULE_MASK; - - const fn new_kind(kind: u32) -> u32 { - assert!(kind < (1 << Self::KIND_BITS)); - kind << Self::KIND_OFFSET - } - - const VM_CONTEXT_KIND: u32 = Self::new_kind(0b0000); - const VM_STORE_CONTEXT_KIND: u32 = Self::new_kind(0b0001); - const IMPORTED_MEMORY_KIND: u32 = Self::new_kind(0b0010); - const DEFINED_MEMORY_KIND: u32 = Self::new_kind(0b0011); - const IMPORTED_TABLE_KIND: u32 = Self::new_kind(0b0100); - const DEFINED_TABLE_KIND: u32 = Self::new_kind(0b0101); - const IMPORTED_GLOBAL_KIND: u32 = Self::new_kind(0b0110); - const DEFINED_GLOBAL_KIND: u32 = Self::new_kind(0b0111); - const GC_HEAP_KIND: u32 = Self::new_kind(0b1000); - const VM_MEMORY_DEFINITION_KIND: u32 = Self::new_kind(0b1001); - - /// Encode this key into a raw `u32` suitable for use as an - /// `AliasRegionData::user_id`. - pub(crate) fn into_raw(self) -> u32 { - match self { - AliasRegionKey::Vm { ty, offset } => { - debug_assert_eq!(offset & Self::KIND_MASK, 0); - let kind = match ty { - VmType::VMContext => Self::VM_CONTEXT_KIND, - VmType::VMStoreContext => Self::VM_STORE_CONTEXT_KIND, - VmType::VMMemoryDefinition => Self::VM_MEMORY_DEFINITION_KIND, - }; - kind | (offset & Self::OFFSET_MASK) - } - AliasRegionKey::PublicMemory => Self::IMPORTED_MEMORY_KIND, - AliasRegionKey::DefinedMemory { module, index } => { - debug_assert_eq!( - module.as_u32() & !Self::MODULE_MASK >> Self::MODULE_OFFSET, - 0 - ); - debug_assert_eq!(index.as_u32() & !Self::INDEX_MASK, 0); - Self::DEFINED_MEMORY_KIND - | (module.as_u32() << Self::MODULE_OFFSET) - | index.as_u32() - } - AliasRegionKey::PublicTable => Self::IMPORTED_TABLE_KIND, - AliasRegionKey::DefinedTable { module, index } => { - debug_assert_eq!( - module.as_u32() & !Self::MODULE_MASK >> Self::MODULE_OFFSET, - 0 - ); - debug_assert_eq!(index.as_u32() & !Self::INDEX_MASK, 0); - Self::DEFINED_TABLE_KIND | (module.as_u32() << Self::MODULE_OFFSET) | index.as_u32() - } - AliasRegionKey::PublicGlobal => Self::IMPORTED_GLOBAL_KIND, - AliasRegionKey::DefinedGlobal { module, index } => { - debug_assert_eq!( - module.as_u32() & !Self::MODULE_MASK >> Self::MODULE_OFFSET, - 0 - ); - debug_assert_eq!(index.as_u32() & !Self::INDEX_MASK, 0); - Self::DEFINED_GLOBAL_KIND - | (module.as_u32() << Self::MODULE_OFFSET) - | index.as_u32() - } - AliasRegionKey::GcHeap => Self::GC_HEAP_KIND, - } - } -} - -impl fmt::Debug for AliasRegionKey { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - AliasRegionKey::Vm { ty, offset } => write!(f, "{ty:?}+{offset:#x}"), - AliasRegionKey::PublicMemory => write!(f, "PublicMemory"), - AliasRegionKey::DefinedMemory { module, index } => { - write!(f, "DefinedMemory({module:?}, {index:?})") - } - AliasRegionKey::PublicTable => write!(f, "PublicTable"), - AliasRegionKey::DefinedTable { module, index } => { - write!(f, "DefinedTable({module:?}, {index:?})") - } - AliasRegionKey::PublicGlobal => write!(f, "PublicGlobal"), - AliasRegionKey::DefinedGlobal { module, index } => { - write!(f, "DefinedGlobal({module:?}, {index:?})") - } - AliasRegionKey::GcHeap => write!(f, "GcHeap"), - } - } -} - -impl From for ir::AliasRegionData { - fn from(key: AliasRegionKey) -> ir::AliasRegionData { - ir::AliasRegionData { - user_id: key.into_raw(), - description: format!("{key:?}").into(), - } - } -} diff --git a/crates/cranelift/src/compiler.rs b/crates/cranelift/src/compiler.rs index 53c0c8fdcf1c..68e67fb325a7 100644 --- a/crates/cranelift/src/compiler.rs +++ b/crates/cranelift/src/compiler.rs @@ -1,11 +1,12 @@ use crate::TRAP_INTERNAL_ASSERT; -use crate::alias_region_key::{AliasRegionKey, VmType}; +use crate::alias_region::AliasRegions; use crate::debug::DwarfSectionRelocTarget; use crate::func_environ::FuncEnvironment; use crate::translate::FuncTranslator; use crate::{BuiltinFunctionSignatures, builder::LinkOptions, wasm_call_signature}; use crate::{CompiledFunction, ModuleTextBuilder, array_call_signature}; use cranelift_codegen::binemit::CodeOffset; +use cranelift_codegen::cursor::FuncCursor; use cranelift_codegen::inline::InlineCommand; use cranelift_codegen::ir::condcodes::IntCC; use cranelift_codegen::ir::{ @@ -39,7 +40,7 @@ use wasmtime_environ::obj::{ELF_WASMTIME_EXCEPTIONS, ELF_WASMTIME_FRAMES}; use wasmtime_environ::{ Abi, AddressMapSection, BuiltinFunctionIndex, CacheStore, CompileError, CompiledFunctionBody, DefinedFuncIndex, FlagValue, FrameInstPos, FrameStackShape, FrameStateSlotBuilder, - FrameTableBuilder, FuncKey, FunctionBodyData, FunctionLoc, HostCall, Inlining, + FrameTableBuilder, FuncKey, FunctionBodyData, FunctionLoc, GetPtrSize, HostCall, Inlining, InliningCompiler, ModulePC, ModuleStartup, ModuleTranslation, ModuleTypesBuilder, PtrSize, StackMapSection, StaticModuleIndex, TrapEncodingBuilder, TrapSentinel, TripleExt, Tunables, WasmFuncType, WasmValType, prelude::*, @@ -209,6 +210,7 @@ impl Compiler { let pointer_type = isa.pointer_type(); let wasm_call_sig = wasm_call_signature(isa, wasm_func_ty, &self.tunables); let array_call_sig = array_call_signature(isa); + let mut alias_regions = AliasRegions::new(isa.pointer_bytes()); let mut compiler = self.function_compiler(); let func = ir::Function::with_name_signature(key_to_name(key), wasm_call_sig); @@ -224,18 +226,13 @@ impl Compiler { // that's what we are assuming with our offsets below. self.debug_assert_vmctx_kind( &mut builder, + &mut alias_regions, caller_vmctx, wasmtime_environ::VMCONTEXT_MAGIC, ); let ptr = isa.pointer_bytes(); - let store_ctx_offset = ptr.vmcontext_store_context(); - let region = vmctx_alias_region(builder.func, store_ctx_offset.into()); - let vm_store_context = builder.ins().load( - pointer_type, - MemFlagsData::trusted().with_alias_region(Some(region)), - caller_vmctx, - i32::from(store_ctx_offset), - ); + let vm_store_context = + alias_regions.vmctx_store_context(&mut builder.cursor(), caller_vmctx); save_last_wasm_exit_fp_and_pc(&mut builder, pointer_type, &ptr, vm_store_context); // Spill all wasm arguments to the stack in `ValRaw` slots. @@ -266,34 +263,21 @@ impl Compiler { // Increment the "execution version" on the VMStoreContext if // guest debugging is enabled. if self.tunables.debug_guest { - let store_ctx_offset = ptr_size.vmctx_store_context(); - let region = vmctx_alias_region(builder.func, store_ctx_offset.into()); - let vmstore_ctx_ptr = builder.ins().load( - pointer_type, - MemFlagsData::trusted() - .with_readonly() - .with_alias_region(Some(region)), - caller_vmctx, - i32::from(store_ctx_offset), - ); - let old_version = builder.ins().load( - ir::types::I64, - MemFlagsData::trusted(), - vmstore_ctx_ptr, - i32::from(ptr_size.vmstore_context_execution_version()), - ); + let vmstore_ctx_ptr = + alias_regions.vmctx_store_context(&mut builder.cursor(), caller_vmctx); + let old_version = alias_regions + .vmstore_context_execution_version(&mut builder.cursor(), vmstore_ctx_ptr); let new_version = builder.ins().iadd_imm_s(old_version, 1); - builder.ins().store( - MemFlagsData::trusted(), - new_version, + alias_regions.store_vmstore_context_execution_version( + &mut builder.cursor(), vmstore_ctx_ptr, - i32::from(ptr_size.vmstore_context_execution_version()), + new_version, ); } // Invoke `raise` if the callee (host) returned an error. let succeeded = builder.func.dfg.inst_results(call)[0]; - self.raise_if_host_trapped(&mut builder, caller_vmctx, succeeded); + self.raise_if_host_trapped(&mut builder, &mut alias_regions, caller_vmctx, succeeded); // Return results from the array as native return values. let results = @@ -317,6 +301,7 @@ impl Compiler { let isa = &*self.isa; let ptr_size = isa.pointer_bytes(); let pointer_type = isa.pointer_type(); + let mut alias_regions = AliasRegions::new(ptr_size); let sigs = BuiltinFunctionSignatures::new(self); let (builtin_func_index, wasm_sig) = match key { @@ -341,21 +326,26 @@ impl Compiler { // Debug-assert that this is the right kind of vmctx, and then // additionally perform the "routine of the exit trampoline" of saving // fp/pc/etc. - self.debug_assert_vmctx_kind(&mut builder, vmctx, wasmtime_environ::VMCONTEXT_MAGIC); - let store_ctx_offset = ptr_size.vmcontext_store_context(); - let region = vmctx_alias_region(builder.func, store_ctx_offset.into()); - let vm_store_context = builder.ins().load( - pointer_type, - MemFlagsData::trusted().with_alias_region(Some(region)), + self.debug_assert_vmctx_kind( + &mut builder, + &mut alias_regions, vmctx, - store_ctx_offset, + wasmtime_environ::VMCONTEXT_MAGIC, ); + let vm_store_context = alias_regions.vmctx_store_context(&mut builder.cursor(), vmctx); save_last_wasm_exit_fp_and_pc(&mut builder, pointer_type, &ptr_size, vm_store_context); // Now it's time to delegate to the actual builtin. Forward all our own // arguments to the libcall itself. let args = builder.block_params(block0).to_vec(); - let call = self.call_builtin(&mut builder, vmctx, &args, builtin_func_index, host_sig); + let call = self.call_builtin( + &mut builder, + &mut alias_regions, + vmctx, + &args, + builtin_func_index, + host_sig, + ); let results = builder.func.dfg.inst_results(call).to_vec(); // Libcalls do not explicitly jump/raise on traps but instead return a @@ -366,13 +356,13 @@ impl Compiler { // process it here. match builtin_func_index.trap_sentinel() { Some(TrapSentinel::Falsy) => { - self.raise_if_host_trapped(&mut builder, vmctx, results[0]); + self.raise_if_host_trapped(&mut builder, &mut alias_regions, vmctx, results[0]); } Some(TrapSentinel::NegativeTwo) => { let ty = builder.func.dfg.value_type(results[0]); let trapped = builder.ins().iconst(ty, -2); let succeeded = builder.ins().icmp(IntCC::NotEqual, results[0], trapped); - self.raise_if_host_trapped(&mut builder, vmctx, succeeded); + self.raise_if_host_trapped(&mut builder, &mut alias_regions, vmctx, succeeded); } Some(TrapSentinel::Negative) => { let ty = builder.func.dfg.value_type(results[0]); @@ -381,13 +371,13 @@ impl Compiler { builder .ins() .icmp(IntCC::SignedGreaterThanOrEqual, results[0], zero); - self.raise_if_host_trapped(&mut builder, vmctx, succeeded); + self.raise_if_host_trapped(&mut builder, &mut alias_regions, vmctx, succeeded); } Some(TrapSentinel::NegativeOne) => { let ty = builder.func.dfg.value_type(results[0]); let minus_one = builder.ins().iconst(ty, -1); let succeeded = builder.ins().icmp(IntCC::NotEqual, results[0], minus_one); - self.raise_if_host_trapped(&mut builder, vmctx, succeeded); + self.raise_if_host_trapped(&mut builder, &mut alias_regions, vmctx, succeeded); } None => {} } @@ -542,37 +532,44 @@ impl wasmtime_environ::Compiler for Compiler { let vmctx = context .func .create_global_value(ir::GlobalValueData::VMContext); - let interrupts_region = vmctx_alias_region( - &mut context.func, - func_env.offsets.ptr.vmctx_store_context().into(), - ); - let interrupts_flags = context + + let vmctx_store_context_region = + func_env.alias_regions.vmctx_region_for_use_in_ir_global( + &mut context.func, + func_env.offsets.ptr.vmctx_store_context().into(), + ); + + let flags = context .func .dfg .mem_flags .insert( MemFlagsData::trusted() .with_readonly() - .with_alias_region(Some(interrupts_region)), + .with_can_move() + .with_alias_region(Some(vmctx_store_context_region)), ) .unwrap(); - let interrupts_ptr = context.func.create_global_value(ir::GlobalValueData::Load { + + let vmstore_ctx_ptr = context.func.create_global_value(ir::GlobalValueData::Load { base: vmctx, offset: i32::from(func_env.offsets.ptr.vmctx_store_context()).into(), global_type: isa.pointer_type(), - flags: interrupts_flags, + flags, }); - let stack_limit_flags = context + + let flags = context .func .dfg .mem_flags .insert(MemFlagsData::trusted()) .unwrap(); + let stack_limit = context.func.create_global_value(ir::GlobalValueData::Load { - base: interrupts_ptr, + base: vmstore_ctx_ptr, offset: i32::from(func_env.offsets.ptr.vmstore_context_stack_limit()).into(), global_type: isa.pointer_type(), - flags: stack_limit_flags, + flags, }); if self.tunables.signals_based_traps { context.func.stack_limit = Some(stack_limit); @@ -632,8 +629,10 @@ impl wasmtime_environ::Compiler for Compiler { FuncKey::DefinedWasmFunction(module_index, def_func_index), types[sig].unwrap_func(), symbol, - self.isa.pointer_bytes().vmctx_store_context().into(), wasmtime_environ::VMCONTEXT_MAGIC, + |alias_regions, _pointer_type, cursor, vmctx| { + alias_regions.vmctx_store_context(cursor, vmctx) + }, ) } @@ -678,8 +677,10 @@ impl wasmtime_environ::Compiler for Compiler { FuncKey::ModuleStartup(Abi::Wasm, module), ty, symbol, - self.isa.pointer_bytes().vmctx_store_context().into(), wasmtime_environ::VMCONTEXT_MAGIC, + |alias_regions, _pointer_type, cursor, vmctx| { + alias_regions.vmctx_store_context(cursor, vmctx) + }, ), // Delegate to a helper to finish compiling this. Abi::Wasm => self.compile_module_startup(translation, types, key, ty), @@ -1301,12 +1302,15 @@ impl Compiler { /// Additionally in the future for pulley this will emit a special trap /// opcode for Pulley itself to cease interpretation and exit the /// interpreter. - pub fn raise_if_host_trapped( + pub fn raise_if_host_trapped( &self, builder: &mut FunctionBuilder<'_>, + alias_regions: &mut AliasRegions, vmctx: ir::Value, succeeded: ir::Value, - ) { + ) where + O: GetPtrSize, + { let trapped_block = builder.create_block(); let continuation_block = builder.create_block(); builder.set_cold_block(trapped_block); @@ -1320,7 +1324,14 @@ impl Compiler { builder.switch_to_block(trapped_block); let sigs = BuiltinFunctionSignatures::new(self); let sig = sigs.host_signature(BuiltinFunctionIndex::raise()); - self.call_builtin(builder, vmctx, &[vmctx], BuiltinFunctionIndex::raise(), sig); + self.call_builtin( + builder, + alias_regions, + vmctx, + &[vmctx], + BuiltinFunctionIndex::raise(), + sig, + ); builder.ins().trap(TRAP_INTERNAL_ASSERT); builder.switch_to_block(continuation_block); @@ -1328,34 +1339,33 @@ impl Compiler { /// Helper to load the core `builtin` from `vmctx` and invoke it with /// `args`. - fn call_builtin( + fn call_builtin( &self, builder: &mut FunctionBuilder<'_>, + alias_regions: &mut AliasRegions, vmctx: ir::Value, args: &[ir::Value], builtin: BuiltinFunctionIndex, sig: ir::Signature, - ) -> ir::Inst { + ) -> ir::Inst + where + O: GetPtrSize, + { let isa = &*self.isa; - let ptr_size = isa.pointer_bytes(); let pointer_type = isa.pointer_type(); // Builtins are stored in an array in all `VMContext`s. First load the // base pointer of the array and then load the entry of the array that // corresponds to this builtin. - let mem_flags = ir::MemFlagsData::trusted().with_readonly(); - let builtins_offset = ptr_size.vmcontext_builtin_functions(); - let region = vmctx_alias_region(builder.func, builtins_offset.into()); - let array_addr = builder.ins().load( + let array_addr = alias_regions.vmctx_builtin_functions(&mut builder.cursor(), vmctx); + + let body_offset = i32::try_from(builtin.index() * pointer_type.bytes()).unwrap(); + let func_addr = builder.ins().load( pointer_type, - mem_flags.with_alias_region(Some(region)), - vmctx, - i32::from(builtins_offset), + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + array_addr, + body_offset, ); - let body_offset = i32::try_from(builtin.index() * pointer_type.bytes()).unwrap(); - let func_addr = builder - .ins() - .load(pointer_type, mem_flags, array_addr, body_offset); let sig = builder.func.import_signature(sig); self.call_indirect_host(builder, builtin, sig, func_addr, args) @@ -1386,24 +1396,19 @@ impl Compiler { builder.ins().trapz(enough_capacity, TRAP_INTERNAL_ASSERT); } - fn debug_assert_vmctx_kind( + fn debug_assert_vmctx_kind( &self, builder: &mut FunctionBuilder, + alias_regions: &mut AliasRegions, vmctx: ir::Value, expected_vmctx_magic: u32, - ) { + ) where + O: GetPtrSize, + { if !self.emit_debug_checks { return; } - let magic_region = vmctx_alias_region(builder.func, 0); - let magic = builder.ins().load( - ir::types::I32, - MemFlagsData::trusted() - .with_endianness(self.isa.endianness()) - .with_alias_region(Some(magic_region)), - vmctx, - 0, - ); + let magic = alias_regions.vmctx_magic(&mut builder.cursor(), vmctx); let is_expected_vmctx = builder.ins().icmp_imm_s( ir::condcodes::IntCC::Equal, magic, @@ -1418,13 +1423,19 @@ impl Compiler { callee_key: FuncKey, callee_sig: &WasmFuncType, symbol: &str, - vm_store_context_offset: u32, expected_vmctx_magic: u32, + mut load_vm_store_context: impl FnMut( + &mut AliasRegions, + ir::Type, + &mut FuncCursor<'_>, + ir::Value, + ) -> ir::Value, ) -> Result { log::trace!("compiling array-to-wasm trampoline: {trampoline_key:?} = {symbol:?}"); let isa = &*self.isa; let pointer_type = isa.pointer_type(); + let mut alias_regions = AliasRegions::new(isa.pointer_bytes()); let wasm_call_sig = wasm_call_signature(isa, callee_sig, &self.tunables); let array_call_sig = array_call_signature(isa); @@ -1455,13 +1466,23 @@ impl Compiler { // // Assert that we were really given a core Wasm vmctx, since that's // what we are assuming with our offsets below. - self.debug_assert_vmctx_kind(&mut builder, vmctx, expected_vmctx_magic); + self.debug_assert_vmctx_kind( + &mut builder, + &mut alias_regions, + vmctx, + expected_vmctx_magic, + ); + let vm_store_ctx = load_vm_store_context( + &mut alias_regions, + pointer_type, + &mut builder.cursor(), + vmctx, + ); save_last_wasm_entry_context( &mut builder, pointer_type, &self.isa.pointer_bytes(), - vm_store_context_offset, - vmctx, + vm_store_ctx, try_call_block, ); @@ -1784,38 +1805,13 @@ fn clif_to_env_breakpoints( Ok(()) } -/// Insert (deduplicated) an alias region for the `VMContext` field at `offset`. -/// -/// This is the trampoline-side equivalent of -/// `FuncEnvironment::vmctx_alias_region`, for the trampoline compilers that do -/// not have a `FuncEnvironment` on hand. -fn vmctx_alias_region(func: &mut ir::Function, offset: u32) -> ir::AliasRegion { - func.dfg.alias_regions.insert( - AliasRegionKey::Vm { - ty: VmType::VMContext, - offset, - } - .into(), - ) -} - fn save_last_wasm_entry_context( builder: &mut FunctionBuilder, pointer_type: ir::Type, ptr_size: &dyn PtrSize, - vm_store_context_offset: u32, - vmctx: Value, + vm_store_context: ir::Value, block: ir::Block, ) { - // First we need to get the `VMStoreContext`. - let region = vmctx_alias_region(builder.func, vm_store_context_offset); - let vm_store_context = builder.ins().load( - pointer_type, - MemFlagsData::trusted().with_alias_region(Some(region)), - vmctx, - i32::try_from(vm_store_context_offset).unwrap(), - ); - // Save the current fp/sp of the entry trampoline into the `VMStoreContext`. let fp = builder.ins().get_frame_pointer(pointer_type); builder.ins().store( diff --git a/crates/cranelift/src/compiler/component.rs b/crates/cranelift/src/compiler/component.rs index 61cc9e6872bc..96962933fdc1 100644 --- a/crates/cranelift/src/compiler/component.rs +++ b/crates/cranelift/src/compiler/component.rs @@ -1,6 +1,8 @@ //! Compilation support for the component model. -use crate::alias_region_key::{AliasRegionKey, VmType}; +use std::marker::PhantomData; + +use crate::alias_region::AliasRegions; use crate::func_environ::BuiltinFunctions; use crate::trap::TranslateTrap; use crate::{ @@ -11,6 +13,7 @@ use cranelift_codegen::ir::condcodes::IntCC; use cranelift_codegen::ir::{self, InstBuilder, MemFlagsData, Value}; use cranelift_codegen::isa::{CallConv, TargetIsa}; use cranelift_frontend::FunctionBuilder; +use wasmtime_environ::GetPtrSize; use wasmtime_environ::error::{Result, bail}; use wasmtime_environ::{ Abi, BuiltinFunctionIndex, CompiledFunctionBody, EntityRef, FuncKey, HostCall, PanicOnOom as _, @@ -28,6 +31,7 @@ struct TrampolineCompiler<'a> { block0: ir::Block, signature: &'a WasmFuncType, builtins: BuiltinFunctions, + alias_regions: AliasRegions>, } /// What host functions can be called, used in `translate_hostcall` below. @@ -111,16 +115,18 @@ impl<'a> TrampolineCompiler<'a> { crate::wasm_call_signature(isa, signature, &compiler.tunables), ); let (builder, block0) = func_compiler.builder(func); + let offsets = VMComponentOffsets::new(isa.pointer_bytes(), component); TrampolineCompiler { compiler, isa, builder, component, types, - offsets: VMComponentOffsets::new(isa.pointer_bytes(), component), + offsets, block0, signature, builtins: BuiltinFunctions::new(compiler), + alias_regions: AliasRegions::new(offsets), } } @@ -1427,8 +1433,12 @@ impl<'a> TrampolineCompiler<'a> { fn raise_if_host_trapped(&mut self, succeeded: ir::Value) { let caller_vmctx = self.caller_vmctx(); - self.compiler - .raise_if_host_trapped(&mut self.builder, caller_vmctx, succeeded); + self.compiler.raise_if_host_trapped( + &mut self.builder, + &mut self.alias_regions, + caller_vmctx, + succeeded, + ); } fn raise_if_transcode_trapped(&mut self, amount_copied: ir::Value) { @@ -1548,12 +1558,18 @@ impl<'a> TrampolineCompiler<'a> { traps.trapz(builder, may_leave_bit, TRAP_CANNOT_LEAVE_COMPONENT); } - fn traps(&mut self) -> (TrapTranslator<'_>, &mut FunctionBuilder<'a>) { + fn traps( + &mut self, + ) -> ( + TrapTranslator<'_, VMComponentOffsets>, + &mut FunctionBuilder<'a>, + ) { ( TrapTranslator { compiler: self.compiler, vmctx: self.caller_vmctx(), builtins: &mut self.builtins, + alias_regions: &mut self.alias_regions, }, &mut self.builder, ) @@ -1570,36 +1586,22 @@ impl<'a> TrampolineCompiler<'a> { /// `VMComponentContext` if it's otherwise unused. fn load_vm_store_context(&mut self) -> ir::Value { let caller_vmctx = self.abi_load_params()[1]; - let offset = self.offsets.ptr.vmctx_store_context(); - let region = self.builder.func.dfg.alias_regions.insert( - AliasRegionKey::Vm { - ty: VmType::VMContext, - offset: offset.into(), - } - .into(), - ); - self.builder.ins().load( - self.isa.pointer_type(), - ir::MemFlagsData::trusted() - .with_readonly() - .with_alias_region(Some(region)) - .with_can_move(), - caller_vmctx, - i32::from(offset), - ) + self.alias_regions + .vmctx_store_context(&mut self.builder.cursor(), caller_vmctx) } } // XXX: we can't implement this for `TrampolineCompiler` directly because it // stores `FunctionBuilder` internally, but this needs to take the builder as an // argument. -struct TrapTranslator<'a> { +struct TrapTranslator<'a, O: GetPtrSize> { compiler: &'a Compiler, vmctx: ir::Value, + alias_regions: &'a mut AliasRegions, builtins: &'a mut BuiltinFunctions, } -impl TranslateTrap for TrapTranslator<'_> { +impl TranslateTrap for TrapTranslator<'_, O> { fn compiler(&self) -> &Compiler { self.compiler } @@ -1608,6 +1610,10 @@ impl TranslateTrap for TrapTranslator<'_> { self.vmctx } + fn alias_regions(&mut self) -> &mut AliasRegions { + self.alias_regions + } + fn builtin_funcref( &mut self, builder: &mut FunctionBuilder<'_>, @@ -1617,7 +1623,7 @@ impl TranslateTrap for TrapTranslator<'_> { } } -fn checked_native_addr( +fn checked_native_addr, O: GetPtrSize>( traps: &mut T, builder: &mut FunctionBuilder<'_>, isa: &(dyn TargetIsa + 'static), @@ -1697,8 +1703,17 @@ impl ComponentCompiler for Compiler { FuncKey::ComponentTrampoline(Abi::Wasm, trampoline_index), sig, symbol, - offsets.vm_store_context(), wasmtime_environ::component::VMCOMPONENT_MAGIC, + |_alias_regions, pointer_type, cursor, vmctx| { + // TODO: `VMComponentContext` doesn't have its own alias + // region or helpers yet. + cursor.ins().load( + pointer_type, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + i32::try_from(offsets.vm_store_context()).unwrap(), + ) + }, )?); } @@ -1719,6 +1734,7 @@ impl ComponentCompiler for Compiler { let pointer_type = self.isa.pointer_type(); self.debug_assert_vmctx_kind( &mut c.builder, + &mut c.alias_regions, vmctx, wasmtime_environ::component::VMCOMPONENT_MAGIC, ); @@ -1769,8 +1785,17 @@ impl ComponentCompiler for Compiler { FuncKey::UnsafeIntrinsic(Abi::Wasm, intrinsic), &wasm_func_ty, symbol, - offsets.vm_store_context(), wasmtime_environ::component::VMCOMPONENT_MAGIC, + |_alias_regions, pointer_type, cursor, vmctx| { + // TODO: `VMComponentContext` doesn't have its own alias + // region or helpers yet. + cursor.ins().load( + pointer_type, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + vmctx, + i32::try_from(offsets.vm_store_context()).unwrap(), + ) + }, )?); } @@ -1805,6 +1830,7 @@ impl ComponentCompiler for Compiler { builder, ptr, traps: &mut traps, + phantom: PhantomData, }; match intrinsic_compiler.translate(intrinsic, ¶ms)? { Some(value) => c.abi_store_results(&[value]), @@ -2048,14 +2074,23 @@ impl TrampolineCompiler<'_> { /// This type itself is more of a context type of sorts where it maintains /// little-to-no state and instead just weaves together all that's necessary for /// translating an intrinsic. -pub struct UnsafeIntrinsicCompiler<'a, 'b, T: TranslateTrap> { +pub struct UnsafeIntrinsicCompiler<'a, 'b, T, O> +where + T: TranslateTrap, + O: GetPtrSize, +{ pub isa: &'a (dyn TargetIsa + 'static), pub builder: &'a mut FunctionBuilder<'b>, pub ptr: u8, pub traps: &'a mut T, + pub phantom: PhantomData, } -impl UnsafeIntrinsicCompiler<'_, '_, T> { +impl UnsafeIntrinsicCompiler<'_, '_, T, O> +where + T: TranslateTrap, + O: GetPtrSize, +{ /// Translates the `intrinsic` provided which is provided `params` as /// arguments. /// @@ -2108,23 +2143,10 @@ impl UnsafeIntrinsicCompiler<'_, '_, T> { let store_ctx = self.load_vm_store_context(params); // Load the `*mut T` out of the `VMStoreContext`. - let offset = self.ptr.vmstore_context_store_data(); - let region = self.builder.func.dfg.alias_regions.insert( - AliasRegionKey::Vm { - ty: VmType::VMStoreContext, - offset: offset.into(), - } - .into(), - ); - let data_address = self.builder.ins().load( - pointer_type, - ir::MemFlagsData::trusted() - .with_readonly() - .with_alias_region(Some(region)) - .with_can_move(), - store_ctx, - i32::from(offset), - ); + let data_address = self + .traps + .alias_regions() + .vmstore_context_store_data(&mut self.builder.cursor(), store_ctx); // Zero-extend the address if we are on a 32-bit architecture. let data_address = match pointer_type.bits() { @@ -2392,23 +2414,9 @@ impl UnsafeIntrinsicCompiler<'_, '_, T> { /// `VMComponentContext` if it's otherwise unused. fn load_vm_store_context(&mut self, params: &[ir::Value]) -> ir::Value { let caller_vmctx = params[1]; - let offset = self.ptr.vmctx_store_context(); - let region = self.builder.func.dfg.alias_regions.insert( - AliasRegionKey::Vm { - ty: VmType::VMContext, - offset: offset.into(), - } - .into(), - ); - self.builder.ins().load( - self.isa.pointer_type(), - ir::MemFlagsData::trusted() - .with_readonly() - .with_alias_region(Some(region)) - .with_can_move(), - caller_vmctx, - i32::from(offset), - ) + self.traps + .alias_regions() + .vmctx_store_context(&mut self.builder.cursor(), caller_vmctx) } } diff --git a/crates/cranelift/src/func_environ.rs b/crates/cranelift/src/func_environ.rs index 03c831844f7a..8bd8c8701343 100644 --- a/crates/cranelift/src/func_environ.rs +++ b/crates/cranelift/src/func_environ.rs @@ -1,7 +1,7 @@ mod gc; pub(crate) mod stack_switching; -use crate::alias_region_key::{AliasRegionKey, VmType}; +use crate::alias_region::AliasRegions; use crate::compiler::Compiler; use crate::translate::{ FuncTranslationStacks, GlobalVariable, Heap, HeapData, MemoryKind, StructFieldsVec, TableData, @@ -27,6 +27,7 @@ use cranelift_frontend::Variable; use cranelift_frontend::{FuncInstBuilder, FunctionBuilder}; use smallvec::{SmallVec, smallvec}; use std::iter::Peekable; +use std::marker::PhantomData; use std::mem; use wasmparser::{ BranchHint, FuncValidator, Operator, SectionLimitedIntoIter, WasmModuleResources, @@ -243,7 +244,7 @@ pub struct FuncEnvironment<'module_environment> { func_body_offset: usize, /// Cached alias regions for alias analysis. - alias_regions: std::collections::HashMap, + pub(crate) alias_regions: AliasRegions>, } impl<'module_environment> FuncEnvironment<'module_environment> { @@ -269,9 +270,11 @@ impl<'module_environment> FuncEnvironment<'module_environment> { // being unused from the compiler. let _ = BuiltinFunctions::raise; + let isa = compiler.isa(); + let offsets = VMOffsets::new(isa.pointer_bytes(), &translation.module); Self { key, - isa: compiler.isa(), + isa, module: &translation.module, compiler, types, @@ -290,7 +293,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> { vmctx: None, vm_store_context: None, builtin_functions, - offsets: VMOffsets::new(compiler.isa().pointer_bytes(), &translation.module), + offsets, tunables, fuel_var: Variable::reserved_value(), epoch_deadline_var: Variable::reserved_value(), @@ -314,7 +317,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> { branch_hints, func_body_offset, - alias_regions: std::collections::HashMap::new(), + alias_regions: AliasRegions::new(offsets), } } @@ -355,23 +358,12 @@ impl<'module_environment> FuncEnvironment<'module_environment> { }) } - pub(crate) fn alias_region( - &mut self, - func: &mut Function, - key: AliasRegionKey, - ) -> ir::AliasRegion { - *self - .alias_regions - .entry(key) - .or_insert_with(|| func.dfg.alias_regions.insert(key.into())) - } - pub(crate) fn memory_alias_region( &mut self, func: &mut Function, memory: MemoryIndex, ) -> ir::AliasRegion { - let key = if self.module.is_exported_memory(memory) { + if self.module.is_exported_memory(memory) { // A function that operates on an exported defined memory can be // inlined into a different module caller, where that that caller's // module also imports that exported memory. That caller will access @@ -380,17 +372,17 @@ impl<'module_environment> FuncEnvironment<'module_environment> { // the precise static module index and defined memory index, because // memory accessed with two different alias regions must not // actually alias, or else we will get miscompiles. - AliasRegionKey::PublicMemory + self.alias_regions.public_memory_region(func) } else { match self.module.defined_memory_index(memory) { - Some(def) => AliasRegionKey::DefinedMemory { - module: self.translation.module_index(), - index: def, - }, - None => AliasRegionKey::PublicMemory, + Some(def) => self.alias_regions.defined_memory_region( + func, + self.translation.module_index(), + def, + ), + None => self.alias_regions.public_memory_region(func), } - }; - self.alias_region(func, key) + } } pub(crate) fn table_alias_region( @@ -398,19 +390,19 @@ impl<'module_environment> FuncEnvironment<'module_environment> { func: &mut Function, table: TableIndex, ) -> ir::AliasRegion { - let key = if self.module.is_exported_table(table) { + if self.module.is_exported_table(table) { // See the comment in `memory_alias_region` for details. - AliasRegionKey::PublicTable + self.alias_regions.public_table_region(func) } else { match self.module.defined_table_index(table) { - Some(def) => AliasRegionKey::DefinedTable { - module: self.translation.module_index(), - index: def, - }, - None => AliasRegionKey::PublicTable, + Some(def) => self.alias_regions.defined_table_region( + func, + self.translation.module_index(), + def, + ), + None => self.alias_regions.public_table_region(func), } - }; - self.alias_region(func, key) + } } pub(crate) fn global_alias_region( @@ -418,19 +410,19 @@ impl<'module_environment> FuncEnvironment<'module_environment> { func: &mut Function, global: GlobalIndex, ) -> ir::AliasRegion { - let key = if self.module.is_exported_global(global) { + if self.module.is_exported_global(global) { // See the comment in `memory_alias_region` for details. - AliasRegionKey::PublicGlobal + self.alias_regions.public_global_region(func) } else { match self.module.defined_global_index(global) { - Some(def) => AliasRegionKey::DefinedGlobal { - module: self.translation.module_index(), - index: def, - }, - None => AliasRegionKey::PublicGlobal, + Some(def) => self.alias_regions.defined_global_region( + func, + self.translation.module_index(), + def, + ), + None => self.alias_regions.public_global_region(func), } - }; - self.alias_region(func, key) + } } /// Get the alias region for the storage of a bulk-copy entity. @@ -442,27 +434,13 @@ impl<'module_environment> FuncEnvironment<'module_environment> { match entity { CheckedEntity::Memory(index) => Some(self.memory_alias_region(func, index)), CheckedEntity::Table { table, .. } => Some(self.table_alias_region(func, table)), - CheckedEntity::Array { .. } => Some(self.gc_heap_alias_region(func)), + CheckedEntity::Array { .. } => Some(self.alias_regions.gc_heap_region(func)), CheckedEntity::Data { .. } | CheckedEntity::RuntimeData(_) | CheckedEntity::Elem(_) => { None } } } - pub(crate) fn vmctx_alias_region( - &mut self, - func: &mut Function, - offset: u32, - ) -> ir::AliasRegion { - self.alias_region( - func, - AliasRegionKey::Vm { - ty: VmType::VMContext, - offset, - }, - ) - } - fn get_memory_atomic_wait(&mut self, func: &mut Function, ty: ir::Type) -> ir::FuncRef { match ty { I32 => self.builtin_functions.memory_atomic_wait32(func), @@ -483,7 +461,9 @@ impl<'module_environment> FuncEnvironment<'module_environment> { (vmctx, offset) } else { let from_offset = self.offsets.vmctx_vmglobal_import_from(index); - let region = self.vmctx_alias_region(func, from_offset); + let region = self + .alias_regions + .vmctx_region_for_use_in_ir_global(func, from_offset); let global_flags = func .dfg .mem_flags @@ -520,7 +500,9 @@ impl<'module_environment> FuncEnvironment<'module_environment> { let offset = self.offsets.ptr.vmctx_store_context(); let base = self.vmctx(func); - let region = self.vmctx_alias_region(func, offset.into()); + let region = self + .alias_regions + .vmctx_region_for_use_in_ir_global(func, offset.into()); let ptr_flags = func .dfg .mem_flags @@ -543,19 +525,9 @@ impl<'module_environment> FuncEnvironment<'module_environment> { /// Get the `*mut VMStoreContext` value for our `VMContext`. fn get_vmstore_context_ptr(&mut self, builder: &mut FunctionBuilder) -> ir::Value { - let pointer_type = self.pointer_type(); - let offset = self.offsets.ptr.vmctx_store_context(); let vmctx = self.vmctx_val(&mut builder.cursor()); - let region = self.vmctx_alias_region(builder.func, offset.into()); - builder.ins().load( - pointer_type, - ir::MemFlagsData::trusted() - .with_readonly() - .with_can_move() - .with_alias_region(Some(region)), - vmctx, - i32::from(offset), - ) + self.alias_regions + .vmctx_store_context(&mut builder.cursor(), vmctx) } fn fuel_function_entry(&mut self, builder: &mut FunctionBuilder<'_>) { @@ -852,17 +824,9 @@ impl<'module_environment> FuncEnvironment<'module_environment> { } fn epoch_ptr(&mut self, builder: &mut FunctionBuilder<'_>) -> ir::Value { - let pointer_type = self.pointer_type(); - let base = self.vmctx_val(&mut builder.cursor()); - let offset = self.offsets.ptr.vmctx_epoch_ptr(); - let region = self.vmctx_alias_region(builder.func, offset.into()); - let epoch_ptr = builder.ins().load( - pointer_type, - ir::MemFlagsData::trusted().with_alias_region(Some(region)), - base, - i32::from(offset), - ); - epoch_ptr + let vmctx = self.vmctx_val(&mut builder.cursor()); + self.alias_regions + .vmctx_epoch_ptr(&mut builder.cursor(), vmctx) } fn epoch_load_current(&mut self, builder: &mut FunctionBuilder<'_>) -> ir::Value { @@ -1171,7 +1135,9 @@ impl<'module_environment> FuncEnvironment<'module_environment> { flags: ir::MemFlagsData, ) -> ir::GlobalValue { let vmctx = self.vmctx(func); - let region = self.vmctx_alias_region(func, offset); + let region = self + .alias_regions + .vmctx_region_for_use_in_ir_global(func, offset); let flags = flags.with_alias_region(Some(region)); self.global_load(func, vmctx, offset, flags) } @@ -1259,18 +1225,8 @@ impl<'module_environment> FuncEnvironment<'module_environment> { interned_ty: ModuleInternedTypeIndex, ) -> ir::Value { let vmctx = self.vmctx_val(pos); - let pointer_type = self.pointer_type(); - let mem_flags = ir::MemFlagsData::trusted().with_readonly().with_can_move(); - // Load the base pointer of the array of `VMSharedTypeIndex`es. - let type_ids_offset = self.offsets.ptr.vmctx_type_ids_array(); - let region = self.vmctx_alias_region(pos.func, type_ids_offset.into()); - let shared_indices = pos.ins().load( - pointer_type, - mem_flags.with_alias_region(Some(region)), - vmctx, - i32::from(type_ids_offset), - ); + let shared_indices = self.alias_regions.vmctx_shared_type_ids_array(pos, vmctx); // Calculate the offset in that array for this type's entry. let ty = self.vmshared_type_index_ty(); @@ -1278,7 +1234,12 @@ impl<'module_environment> FuncEnvironment<'module_environment> { // Load the`VMSharedTypeIndex` that this `ModuleInternedTypeIndex` is // associated with at runtime from the array. - pos.ins().load(ty, mem_flags, shared_indices, offset) + pos.ins().load( + ty, + ir::MemFlagsData::trusted().with_readonly().with_can_move(), + shared_indices, + offset, + ) } /// Load the associated `VMSharedTypeIndex` from inside a `*const VMFuncRef`. @@ -1532,7 +1493,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> { } } -impl TranslateTrap for FuncEnvironment<'_> { +impl TranslateTrap> for FuncEnvironment<'_> { fn compiler(&self) -> &Compiler { &self.compiler } @@ -1543,6 +1504,10 @@ impl TranslateTrap for FuncEnvironment<'_> { .expect("Missing vmctx parameter") } + fn alias_regions(&mut self) -> &mut AliasRegions> { + &mut self.alias_regions + } + fn builtin_funcref( &mut self, builder: &mut FunctionBuilder<'_>, @@ -1839,7 +1804,9 @@ impl FuncEnvironment<'_> { (vmctx, base_offset, current_elements_offset) } else { let from_offset = self.offsets.vmctx_vmtable_from(index); - let region = self.vmctx_alias_region(func, from_offset); + let region = self + .alias_regions + .vmctx_region_for_use_in_ir_global(func, from_offset); let table_flags = func .dfg .mem_flags @@ -1947,27 +1914,16 @@ impl FuncEnvironment<'_> { (instance_id, tag_id) } else { // An imported tag -- we need to load the VMTagImport struct. - let vmctx_tag_vmctx_offset = self.offsets.vmctx_vmtag_import_vmctx(tag_index); - let vmctx_tag_index_offset = self.offsets.vmctx_vmtag_import_index(tag_index); let vmctx = self.vmctx_val(&mut builder.cursor()); - let pointer_type = self.pointer_type(); - let vmctx_region = self.vmctx_alias_region(builder.func, vmctx_tag_vmctx_offset); - let from_vmctx = builder.ins().load( - pointer_type, - MemFlagsData::trusted() - .with_readonly() - .with_alias_region(Some(vmctx_region)), + let from_vmctx = self.alias_regions.vmctx_vmtag_import_vmctx( + &mut builder.cursor(), vmctx, - i32::try_from(vmctx_tag_vmctx_offset).unwrap(), + tag_index, ); - let index_region = self.vmctx_alias_region(builder.func, vmctx_tag_index_offset); - let index = builder.ins().load( - I32, - MemFlagsData::trusted() - .with_readonly() - .with_alias_region(Some(index_region)), + let index = self.alias_regions.vmctx_vmtag_import_index( + &mut builder.cursor(), vmctx, - i32::try_from(vmctx_tag_index_offset).unwrap(), + tag_index, ); let builtin = self.builtin_functions.get_instance_id(builder.func); let call = builder.ins().call(builtin, &[from_vmctx]); @@ -2060,30 +2016,13 @@ impl<'a, 'func, 'module_env> Call<'a, 'func, 'module_env> { // Handle direct calls to imported functions. We use an indirect call // so that we don't have to patch the code at runtime. - let pointer_type = self.env.pointer_type(); - let vmctx = self.env.vmctx(self.builder.func); - let base = self.builder.ins().global_value(pointer_type, vmctx); - - let mem_flags = ir::MemFlagsData::trusted().with_readonly().with_can_move(); - - // Load the callee address. - let wasm_call_offset = self - .env - .offsets - .vmctx_vmfunction_import_wasm_call(callee_index); - let body_offset = i32::try_from(wasm_call_offset).unwrap(); // First append the callee vmctx address. - let vmctx_import_offset = self.env.offsets.vmctx_vmfunction_import_vmctx(callee_index); - let vmctx_offset = i32::try_from(vmctx_import_offset).unwrap(); - let vmctx_region = self - .env - .vmctx_alias_region(self.builder.func, vmctx_import_offset); - let callee_vmctx = self.builder.ins().load( - pointer_type, - mem_flags.with_alias_region(Some(vmctx_region)), - base, - vmctx_offset, + let vmctx = self.env.vmctx_val(&mut self.builder.cursor()); + let callee_vmctx = self.env.alias_regions.vmctx_vmfunction_import_vmctx( + &mut self.builder.cursor(), + vmctx, + callee_index, ); real_call_args.push(callee_vmctx); real_call_args.push(caller_vmctx); @@ -2111,6 +2050,7 @@ impl<'a, 'func, 'module_env> Call<'a, 'func, 'module_env> { isa, ptr, traps: self.env, + phantom: PhantomData, }; let result = intrinsic_compiler .translate(*intrinsic, &real_call_args) @@ -2138,14 +2078,10 @@ impl<'a, 'func, 'module_env> Call<'a, 'func, 'module_env> { // and with different functions. Either way, we have to do the // indirect call. None => { - let wasm_call_region = self - .env - .vmctx_alias_region(self.builder.func, wasm_call_offset); - let func_addr = self.builder.ins().load( - pointer_type, - mem_flags.with_alias_region(Some(wasm_call_region)), - base, - body_offset, + let func_addr = self.env.alias_regions.vmctx_vmfunction_import_wasm_call( + &mut self.builder.cursor(), + vmctx, + callee_index, ); Ok(self.indirect_call_inst(sig_ref, func_addr, &real_call_args)) } @@ -3476,24 +3412,12 @@ impl FuncEnvironment<'_> { // This is an imported memory, so load the vmctx/defined index from // the import definition itself. None => { - let vmimport = self.offsets.vmctx_vmmemory_import(index); - - let vmctx_offset = vmimport + u32::from(self.offsets.vmmemory_import_vmctx()); - let vmctx_region = self.vmctx_alias_region(pos.func, vmctx_offset); - let vmctx = pos.ins().load( - self.isa.pointer_type(), - ir::MemFlagsData::trusted().with_alias_region(Some(vmctx_region)), - cur_vmctx, - i32::try_from(vmctx_offset).unwrap(), - ); - let index_offset = vmimport + u32::from(self.offsets.vmmemory_import_index()); - let index_region = self.vmctx_alias_region(pos.func, index_offset); - let index = pos.ins().load( - ir::types::I32, - ir::MemFlagsData::trusted().with_alias_region(Some(index_region)), - cur_vmctx, - i32::try_from(index_offset).unwrap(), - ); + let vmctx = self + .alias_regions + .vmctx_vmmemory_import_vmctx(pos, cur_vmctx, index); + let index = self + .alias_regions + .vmctx_vmmemory_import_index(pos, cur_vmctx, index); (vmctx, index) } } @@ -3514,24 +3438,12 @@ impl FuncEnvironment<'_> { match self.module.defined_table_index(index) { Some(index) => (cur_vmctx, pos.ins().iconst(I32, i64::from(index.as_u32()))), None => { - let vmimport = self.offsets.vmctx_vmtable_import(index); - - let vmctx_offset = vmimport + u32::from(self.offsets.vmtable_import_vmctx()); - let vmctx_region = self.vmctx_alias_region(pos.func, vmctx_offset); - let vmctx = pos.ins().load( - self.isa.pointer_type(), - ir::MemFlagsData::trusted().with_alias_region(Some(vmctx_region)), - cur_vmctx, - i32::try_from(vmctx_offset).unwrap(), - ); - let index_offset = vmimport + u32::from(self.offsets.vmtable_import_index()); - let index_region = self.vmctx_alias_region(pos.func, index_offset); - let index = pos.ins().load( - ir::types::I32, - ir::MemFlagsData::trusted().with_alias_region(Some(index_region)), - cur_vmctx, - i32::try_from(index_offset).unwrap(), - ); + let vmctx = self + .alias_regions + .vmctx_vmtable_import_vmctx(pos, cur_vmctx, index); + let index = self + .alias_regions + .vmctx_vmtable_import_index(pos, cur_vmctx, index); (vmctx, index) } } @@ -3580,14 +3492,9 @@ impl FuncEnvironment<'_> { match self.module.defined_memory_index(index) { Some(def_index) => { if is_shared { - let ptr_offset = self.offsets.vmctx_vmmemory_pointer(def_index); - let region = self.vmctx_alias_region(pos.func, ptr_offset); - let vmmemory_ptr = pos.ins().load( - pointer_type, - ir::MemFlagsData::trusted().with_alias_region(Some(region)), - base, - i32::try_from(ptr_offset).unwrap(), - ); + let vmmemory_ptr = self + .alias_regions + .vmctx_vmmemory_pointer(pos, base, def_index); let vmmemory_definition_offset = i64::from(self.offsets.ptr.vmmemory_definition_current_length()); let vmmemory_definition_ptr = pos @@ -3616,14 +3523,9 @@ impl FuncEnvironment<'_> { } } None => { - let from_offset = self.offsets.vmctx_vmmemory_import_from(index); - let region = self.vmctx_alias_region(pos.func, from_offset); - let vmmemory_ptr = pos.ins().load( - pointer_type, - ir::MemFlagsData::trusted().with_alias_region(Some(region)), - base, - i32::try_from(from_offset).unwrap(), - ); + let vmmemory_ptr = self + .alias_regions + .vmctx_vmmemory_import_from(pos, base, index); if is_shared { let vmmemory_definition_offset = i64::from(self.offsets.ptr.vmmemory_definition_current_length()); @@ -4276,13 +4178,11 @@ impl FuncEnvironment<'_> { // the value 0 to the `VMContext`'s slot for this passive data segment. let vmctx = self.vmctx_val(&mut pos); let new_length = pos.ins().iconst(I32, 0); - let length_offset = self.offsets.vmctx_runtime_data_length(runtime_index); - let region = self.vmctx_alias_region(pos.func, length_offset); - pos.ins().store( - ir::MemFlagsData::trusted().with_alias_region(Some(region)), - new_length, + self.alias_regions.store_vmctx_runtime_data_length( + &mut pos, vmctx, - i32::try_from(length_offset).unwrap(), + runtime_index, + new_length, ); Ok(()) @@ -4563,12 +4463,8 @@ impl FuncEnvironment<'_> { runtime_index: RuntimeDataIndex, ) -> ir::Value { let vmctx = self.vmctx_val(&mut builder.cursor()); - let length_offset = self.offsets.vmctx_runtime_data_length(runtime_index); - let region = self.vmctx_alias_region(builder.func, length_offset); - let flags = ir::MemFlagsData::trusted().with_alias_region(Some(region)); - builder - .ins() - .load(I32, flags, vmctx, i32::try_from(length_offset).unwrap()) + self.alias_regions + .vmctx_runtime_data_length(&mut builder.cursor(), vmctx, runtime_index) } fn load_runtime_data_length_as_pointer( @@ -4586,14 +4482,8 @@ impl FuncEnvironment<'_> { runtime_index: RuntimeDataIndex, ) -> ir::Value { let vmctx = self.vmctx_val(&mut builder.cursor()); - let base_offset = self.offsets.vmctx_runtime_data_base(runtime_index); - let region = self.vmctx_alias_region(builder.func, base_offset); - builder.ins().load( - self.pointer_type(), - ir::MemFlagsData::trusted().with_alias_region(Some(region)), - vmctx, - i32::try_from(base_offset).unwrap(), - ) + self.alias_regions + .vmctx_runtime_data_base(&mut builder.cursor(), vmctx, runtime_index) } pub fn translate_table_copy( diff --git a/crates/cranelift/src/func_environ/gc.rs b/crates/cranelift/src/func_environ/gc.rs index efb67682250e..61c0f876f90f 100644 --- a/crates/cranelift/src/func_environ/gc.rs +++ b/crates/cranelift/src/func_environ/gc.rs @@ -1,7 +1,6 @@ //! Interface to compiling GC-related things. use crate::TRAP_ARRAY_OUT_OF_BOUNDS; -use crate::alias_region_key::AliasRegionKey; use crate::bounds_checks::BoundsCheck; use crate::func_environ::{CheckedEntity, Extension, FuncEnvironment}; use crate::translate::{Heap, HeapData, MemoryKind, StructFieldsVec, TargetEnvironment}; @@ -1392,10 +1391,6 @@ fn initialize_struct_fields( } impl FuncEnvironment<'_> { - pub(crate) fn gc_heap_alias_region(&mut self, func: &mut ir::Function) -> ir::AliasRegion { - self.alias_region(func, AliasRegionKey::GcHeap) - } - /// Flags to use for general-purpose GC loads/stores. /// /// This is used for accesses to the GC heap which aren't expected to trap, but @@ -1403,7 +1398,7 @@ impl FuncEnvironment<'_> { /// is here to ensure that in the face of heap corruption that there's no /// possible UB within Cranelift and/or the runtime. fn gc_memflags(&mut self, func: &mut ir::Function) -> ir::MemFlagsData { - let region = self.gc_heap_alias_region(func); + let region = self.alias_regions.gc_heap_region(func); ir::MemFlagsData::new() .with_trap_code(Some(crate::TRAP_GC_HEAP_CORRUPT)) .with_alias_region(Some(region)) diff --git a/crates/cranelift/src/func_environ/gc/copying.rs b/crates/cranelift/src/func_environ/gc/copying.rs index beaa591a1fb4..9357a4072cc3 100644 --- a/crates/cranelift/src/func_environ/gc/copying.rs +++ b/crates/cranelift/src/func_environ/gc/copying.rs @@ -32,20 +32,10 @@ impl CopyingCompiler { func_env: &mut FuncEnvironment<'_>, builder: &mut FunctionBuilder, ) -> ir::Value { - let pointer_type = func_env.pointer_type(); - let gc_heap_data_offset = func_env.offsets.ptr.vmctx_gc_heap_data(); - let vmctx_region = - func_env.vmctx_alias_region(&mut builder.func, u32::from(gc_heap_data_offset)); let vmctx = func_env.vmctx_val(&mut builder.cursor()); - builder.ins().load( - pointer_type, - ir::MemFlagsData::trusted() - .with_readonly() - .with_can_move() - .with_alias_region(Some(vmctx_region)), - vmctx, - i32::from(gc_heap_data_offset), - ) + func_env + .alias_regions + .vmctx_gc_heap_data(&mut builder.cursor(), vmctx) } /// Load the current bump pointer and active-space end from a `*mut @@ -72,6 +62,21 @@ impl CopyingCompiler { (bump_ptr, active_space_end) } + /// Store the new bump pointer into the given `*mut VMCopyingHeapData`. + fn store_bump_pointer( + func_env: &mut FuncEnvironment<'_>, + builder: &mut FunctionBuilder<'_>, + heap_data_ptr: ir::Value, + end_of_object: ir::Value, + ) { + builder.ins().store( + ir::MemFlagsData::trusted(), + end_of_object, + heap_data_ptr, + i32::from(func_env.offsets.ptr.vmcopying_heap_data_bump_ptr()), + ); + } + /// Round `size` (an `i32`) up to `ALIGN`, returning the result as an `i64`. /// /// Uses `i64` arithmetic so that overflow produces a value larger than any @@ -160,14 +165,7 @@ impl CopyingCompiler { // Update the bump pointer. let end_of_object = builder.ins().ireduce(ir::types::I32, end_64); - let gc_heap_data_offset = u32::from(func_env.offsets.ptr.vmctx_gc_heap_data()); - let vmctx_region = func_env.vmctx_alias_region(&mut builder.func, gc_heap_data_offset); - builder.ins().store( - ir::MemFlagsData::trusted().with_alias_region(Some(vmctx_region)), - end_of_object, - ptr_to_heap_data, - i32::from(func_env.offsets.ptr.vmcopying_heap_data_bump_ptr()), - ); + Self::store_bump_pointer(func_env, builder, ptr_to_heap_data, end_of_object); // Compute the raw pointer to the new object. let base = func_env.get_gc_heap_base(builder)?; diff --git a/crates/cranelift/src/func_environ/gc/drc.rs b/crates/cranelift/src/func_environ/gc/drc.rs index aa5fb971de8a..6b9de7142675 100644 --- a/crates/cranelift/src/func_environ/gc/drc.rs +++ b/crates/cranelift/src/func_environ/gc/drc.rs @@ -30,20 +30,10 @@ impl DrcCompiler { func_env: &mut FuncEnvironment<'_>, builder: &mut FunctionBuilder, ) -> ir::Value { - let ptr_ty = func_env.pointer_type(); - let gc_heap_data_offset = u32::from(func_env.offsets.ptr.vmctx_gc_heap_data()); - let vmctx_region = func_env.vmctx_alias_region(&mut builder.func, gc_heap_data_offset); - let vmctx = func_env.vmctx(&mut builder.func); - let vmctx = builder.ins().global_value(ptr_ty, vmctx); - builder.ins().load( - ptr_ty, - ir::MemFlagsData::trusted() - .with_readonly() - .with_can_move() - .with_alias_region(Some(vmctx_region)), - vmctx, - i32::try_from(gc_heap_data_offset).unwrap(), - ) + let vmctx = func_env.vmctx_val(&mut builder.cursor()); + func_env + .alias_regions + .vmctx_gc_heap_data(&mut builder.cursor(), vmctx) } /// Generate code to load the given GC reference's ref count. diff --git a/crates/cranelift/src/func_environ/gc/null.rs b/crates/cranelift/src/func_environ/gc/null.rs index 1fe51094df94..d9b60d1e4264 100644 --- a/crates/cranelift/src/func_environ/gc/null.rs +++ b/crates/cranelift/src/func_environ/gc/null.rs @@ -12,7 +12,7 @@ use cranelift_frontend::FunctionBuilder; use wasmtime_environ::VMSharedTypeIndex; use wasmtime_environ::null::{EXCEPTION_TAG_DEFINED_OFFSET, EXCEPTION_TAG_INSTANCE_OFFSET}; use wasmtime_environ::{ - GcTypeLayouts, ModuleInternedTypeIndex, PtrSize, TypeIndex, VMGcKind, WasmRefType, WasmResult, + GcTypeLayouts, ModuleInternedTypeIndex, TypeIndex, VMGcKind, WasmRefType, WasmResult, null::NullTypeLayouts, }; @@ -69,18 +69,10 @@ impl NullCompiler { // Load the bump "pointer" (it is actually an index into the GC heap, // not a raw pointer). - let pointer_type = func_env.pointer_type(); - let gc_heap_data_offset = u32::from(func_env.offsets.ptr.vmctx_gc_heap_data()); - let vmctx_region = func_env.vmctx_alias_region(&mut builder.func, gc_heap_data_offset); let vmctx = func_env.vmctx_val(&mut builder.cursor()); - let ptr_to_next = builder.ins().load( - pointer_type, - ir::MemFlagsData::trusted() - .with_readonly() - .with_alias_region(Some(vmctx_region)), - vmctx, - i32::try_from(gc_heap_data_offset).unwrap(), - ); + let ptr_to_next = func_env + .alias_regions + .vmctx_gc_heap_data(&mut builder.cursor(), vmctx); let flags = func_env.gc_memflags(&mut builder.func); let next = builder.ins().load(ir::types::I32, flags, ptr_to_next, 0); @@ -107,7 +99,8 @@ impl NullCompiler { // Check whether the allocation fits in the heap space we have left. let end_of_object = func_env.uadd_overflow_trap(builder, aligned, size, crate::TRAP_ALLOCATION_TOO_LARGE); - let uext_end_of_object = uextend_i32_to_pointer_type(builder, pointer_type, end_of_object); + let uext_end_of_object = + uextend_i32_to_pointer_type(builder, func_env.pointer_type(), end_of_object); let bound = func_env.get_gc_heap_bound(builder)?; let is_in_bounds = builder.ins().icmp( ir::condcodes::IntCC::UnsignedLessThanOrEqual, @@ -146,7 +139,7 @@ impl NullCompiler { // code for big-endian architectures, and I haven't bothered doing that // yet. let base = func_env.get_gc_heap_base(builder)?; - let uext_aligned = uextend_i32_to_pointer_type(builder, pointer_type, aligned); + let uext_aligned = uextend_i32_to_pointer_type(builder, func_env.pointer_type(), aligned); let ptr_to_object = builder.ins().iadd(base, uext_aligned); let kind = builder .ins() diff --git a/crates/cranelift/src/func_environ/stack_switching/instructions.rs b/crates/cranelift/src/func_environ/stack_switching/instructions.rs index 4e58e3ac35ec..60e8e3da0419 100644 --- a/crates/cranelift/src/func_environ/stack_switching/instructions.rs +++ b/crates/cranelift/src/func_environ/stack_switching/instructions.rs @@ -914,21 +914,12 @@ pub(crate) fn tag_address<'a>( ) -> ir::Value { let vmctx = env.vmctx_val(&mut builder.cursor()); let tag_index = wasmtime_environ::TagIndex::from_u32(index); - let pointer_type = env.pointer_type(); if let Some(def_index) = env.module.defined_tag_index(tag_index) { let offset = i32::try_from(env.offsets.vmctx_vmtag_definition(def_index)).unwrap(); builder.ins().iadd_imm_s(vmctx, i64::from(offset)) } else { - let from_offset = env.offsets.vmctx_vmtag_import_from(tag_index); - let region = env.vmctx_alias_region(builder.func, from_offset); - builder.ins().load( - pointer_type, - ir::MemFlagsData::trusted() - .with_readonly() - .with_alias_region(Some(region)), - vmctx, - ir::immediates::Offset32::new(i32::try_from(from_offset).unwrap()), - ) + env.alias_regions + .vmctx_vmtag_import_from(&mut builder.cursor(), vmctx, tag_index) } } @@ -943,14 +934,9 @@ pub fn vmctx_load_stack_chain<'a>( let stack_chain_offset = env.offsets.ptr.vmstore_context_stack_chain().into(); // First we need to get the `VMStoreContext`. - let vm_store_context_offset = env.offsets.ptr.vmctx_store_context(); - let region = env.vmctx_alias_region(builder.func, vm_store_context_offset.into()); - let vm_store_context = builder.ins().load( - env.pointer_type(), - MemFlagsData::trusted().with_alias_region(Some(region)), - vmctx, - vm_store_context_offset, - ); + let vm_store_context = env + .alias_regions + .vmctx_store_context(&mut builder.cursor(), vmctx); VMStackChain::load( env, @@ -972,14 +958,9 @@ pub fn vmctx_store_stack_chain<'a>( let stack_chain_offset = env.offsets.ptr.vmstore_context_stack_chain().into(); // First we need to get the `VMStoreContext`. - let vm_store_context_offset = env.offsets.ptr.vmctx_store_context(); - let region = env.vmctx_alias_region(builder.func, vm_store_context_offset.into()); - let vm_store_context = builder.ins().load( - env.pointer_type(), - MemFlagsData::trusted().with_alias_region(Some(region)), - vmctx, - vm_store_context_offset, - ); + let vm_store_context = env + .alias_regions + .vmctx_store_context(&mut builder.cursor(), vmctx); stack_chain.store(env, builder, vm_store_context, stack_chain_offset) } @@ -996,26 +977,6 @@ pub fn vmctx_set_active_continuation<'a>( vmctx_store_stack_chain(env, builder, vmctx, &chain) } -pub fn vmctx_load_vm_runtime_limits_ptr<'a>( - env: &mut crate::func_environ::FuncEnvironment<'a>, - builder: &mut FunctionBuilder, - vmctx: ir::Value, -) -> ir::Value { - let pointer_type = env.pointer_type(); - let store_ctx_offset = env.offsets.ptr.vmctx_store_context(); - let region = env.vmctx_alias_region(builder.func, store_ctx_offset.into()); - - // The *pointer* to the VMRuntimeLimits does not change within the - // same function, allowing us to set the `read_only` flag. - let flags = ir::MemFlagsData::trusted() - .with_readonly() - .with_alias_region(Some(region)); - - builder - .ins() - .load(pointer_type, flags, vmctx, i32::from(store_ctx_offset)) -} - /// This function generates code that searches for a handler for `tag_address`, /// which must be a `*mut VMTagDefinition`. The search walks up the chain of /// continuations beginning at `start`. @@ -1372,7 +1333,9 @@ pub(crate) fn translate_resume<'a>( // as well as the `VMRuntimeLimits`. // See the comment on `wasmtime_environ::VMStackChain` for a description // of the invariants that we maintain for the various stack limits. - let vm_runtime_limits_ptr = vmctx_load_vm_runtime_limits_ptr(env, builder, vmctx); + let vm_runtime_limits_ptr = env + .alias_regions + .vmctx_store_context(&mut builder.cursor(), vmctx); parent_csi.load_limits_from_vmcontext(env, builder, vm_runtime_limits_ptr, true); resume_csi.write_limits_to_vmcontext(env, builder, vm_runtime_limits_ptr); @@ -1771,7 +1734,9 @@ pub(crate) fn translate_switch<'a>( // Load current runtime limits from `VMContext` and store in the // switcher continuation. - let vm_runtime_limits_ptr = vmctx_load_vm_runtime_limits_ptr(env, builder, vmctx); + let vm_runtime_limits_ptr = env + .alias_regions + .vmctx_store_context(&mut builder.cursor(), vmctx); switcher_contref_csi.load_limits_from_vmcontext(env, builder, vm_runtime_limits_ptr, false); let revision = switcher_contref.get_revision(env, builder); diff --git a/crates/cranelift/src/lib.rs b/crates/cranelift/src/lib.rs index 208e2abff6ef..50c0b26cbe58 100644 --- a/crates/cranelift/src/lib.rs +++ b/crates/cranelift/src/lib.rs @@ -37,7 +37,7 @@ pub use obj::*; mod compiled_function; pub use compiled_function::*; -mod alias_region_key; +mod alias_region; mod bounds_checks; mod builder; mod compiler; diff --git a/crates/cranelift/src/trap.rs b/crates/cranelift/src/trap.rs index 158f3239e73b..3518ff84ade1 100644 --- a/crates/cranelift/src/trap.rs +++ b/crates/cranelift/src/trap.rs @@ -1,25 +1,34 @@ use crate::TRAP_INTERNAL_ASSERT; +use crate::alias_region::AliasRegions; use crate::compiler::Compiler; use cranelift_codegen::cursor::FuncCursor; use cranelift_codegen::ir::condcodes::IntCC; use cranelift_codegen::ir::types::I8; use cranelift_codegen::ir::{self, InstBuilder}; use cranelift_frontend::FunctionBuilder; -use wasmtime_environ::{BuiltinFunctionIndex, TripleExt}; +use wasmtime_environ::{BuiltinFunctionIndex, GetPtrSize, TripleExt}; /// Helper trait to share translation of traps between core functions and /// component trampolines. /// /// Traps are conditionally performed as libcalls when signals-based-traps are /// disabled, for example, but otherwise use the native CLIF `trap` instruction. -pub trait TranslateTrap { +pub trait TranslateTrap +where + Offsets: GetPtrSize, +{ fn compiler(&self) -> &Compiler; + fn vmctx_val(&mut self, cursor: &mut FuncCursor<'_>) -> ir::Value; + + fn alias_regions(&mut self) -> &mut AliasRegions; + fn builtin_funcref( &mut self, builder: &mut FunctionBuilder<'_>, index: BuiltinFunctionIndex, ) -> ir::FuncRef; + fn debug_tags(&self, _srcloc: ir::SourceLoc) -> Vec { vec![] } diff --git a/crates/environ/src/component/vmcomponent_offsets.rs b/crates/environ/src/component/vmcomponent_offsets.rs index 12149161c02f..4983314fc5d8 100644 --- a/crates/environ/src/component/vmcomponent_offsets.rs +++ b/crates/environ/src/component/vmcomponent_offsets.rs @@ -16,6 +16,7 @@ // resource_destructors: [*mut VMFuncRef; component.num_resources], // } +use crate::GetPtrSize; use crate::PtrSize; use crate::component::*; @@ -76,6 +77,15 @@ pub struct VMComponentOffsets

{ size: u32, } +impl GetPtrSize for VMComponentOffsets

{ + type Ptr = P; + + #[inline] + fn get_ptr_size(&self) -> &Self::Ptr { + &self.ptr + } +} + #[inline] fn align(offset: u32, align: u32) -> u32 { assert!(align.is_power_of_two()); diff --git a/crates/environ/src/vmoffsets.rs b/crates/environ/src/vmoffsets.rs index 3437c1467426..df1cbc516fc5 100644 --- a/crates/environ/src/vmoffsets.rs +++ b/crates/environ/src/vmoffsets.rs @@ -565,6 +565,27 @@ pub trait PtrSize { } } +/// A trait to abstract over various types that contain a `P: PtrSize`. +pub trait GetPtrSize { + /// The type that implements `PtrSize`. + type Ptr: PtrSize; + + /// Get a `&P` where `P: PtrSize`. + fn get_ptr_size(&self) -> &Self::Ptr; +} + +impl

GetPtrSize for P +where + P: PtrSize, +{ + type Ptr = Self; + + #[inline] + fn get_ptr_size(&self) -> &Self::Ptr { + self + } +} + /// Type representing the size of a pointer for the current compilation host #[derive(Clone, Copy)] pub struct HostPtr; @@ -722,6 +743,15 @@ impl VMOffsets

{ } } +impl GetPtrSize for VMOffsets

{ + type Ptr = P; + + #[inline] + fn get_ptr_size(&self) -> &Self::Ptr { + &self.ptr + } +} + impl From> for VMOffsets

{ fn from(fields: VMOffsetsFields

) -> VMOffsets

{ let mut ret = Self { diff --git a/tests/disas/aarch64-entry-trampoline.wat b/tests/disas/aarch64-entry-trampoline.wat index 679518b191da..b80d9968c854 100644 --- a/tests/disas/aarch64-entry-trampoline.wat +++ b/tests/disas/aarch64-entry-trampoline.wat @@ -16,8 +16,8 @@ ;; stp d12, d13, [sp, #-0x10]! ;; stp d10, d11, [sp, #-0x10]! ;; stp d8, d9, [sp, #-0x10]! -;; ldr x11, [x0, #8] ;; mov x12, x29 +;; ldr x11, [x0, #8] ;; str x12, [x11, #0x48] ;; mov x12, sp ;; str x12, [x11, #0x40] diff --git a/tests/disas/alias-region-globals.wat b/tests/disas/alias-region-globals.wat index 548e88d8c9be..7a676721fb19 100644 --- a/tests/disas/alias-region-globals.wat +++ b/tests/disas/alias-region-globals.wat @@ -20,7 +20,7 @@ ;; region2 = 1610612736 "PublicGlobal" ;; region3 = 1879048192 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region1 gv3+48 diff --git a/tests/disas/alias-region-memories.wat b/tests/disas/alias-region-memories.wat index 82efb7e6d6c3..e961d478492e 100644 --- a/tests/disas/alias-region-memories.wat +++ b/tests/disas/alias-region-memories.wat @@ -20,7 +20,7 @@ ;; region2 = 536870912 "PublicMemory" ;; region3 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region1 gv3+48 diff --git a/tests/disas/alias-region-tables.wat b/tests/disas/alias-region-tables.wat index 911639d9c024..6a8aceb08036 100644 --- a/tests/disas/alias-region-tables.wat +++ b/tests/disas/alias-region-tables.wat @@ -22,7 +22,7 @@ ;; region3 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; region4 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region1 gv3+48 diff --git a/tests/disas/arith.wat b/tests/disas/arith.wat index d04299bcbede..5da904af2121 100644 --- a/tests/disas/arith.wat +++ b/tests/disas/arith.wat @@ -17,7 +17,7 @@ ;; function u0:0(i64 vmctx, i64) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/array-copy-anyref.wat b/tests/disas/array-copy-anyref.wat index e26105f48e46..58fd5157a3ee 100644 --- a/tests/disas/array-copy-anyref.wat +++ b/tests/disas/array-copy-anyref.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/array-copy-i64.wat b/tests/disas/array-copy-i64.wat index d295a812e556..168fa476486c 100644 --- a/tests/disas/array-copy-i64.wat +++ b/tests/disas/array-copy-i64.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/array-copy-i8.wat b/tests/disas/array-copy-i8.wat index 786d29879a44..31cf57494095 100644 --- a/tests/disas/array-copy-i8.wat +++ b/tests/disas/array-copy-i8.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/array-copy-inline.wat b/tests/disas/array-copy-inline.wat index 8c6141606598..fb5a9f0e4882 100644 --- a/tests/disas/array-copy-inline.wat +++ b/tests/disas/array-copy-inline.wat @@ -19,7 +19,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/array-fill-anyref.wat b/tests/disas/array-fill-anyref.wat index a25e0c0b7264..1e279162cdcb 100644 --- a/tests/disas/array-fill-anyref.wat +++ b/tests/disas/array-fill-anyref.wat @@ -21,7 +21,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -79,7 +79,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -139,7 +139,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/array-fill-externref.wat b/tests/disas/array-fill-externref.wat index 46dfb2cc8b22..ecd08edfe5c0 100644 --- a/tests/disas/array-fill-externref.wat +++ b/tests/disas/array-fill-externref.wat @@ -17,7 +17,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -75,7 +75,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/array-fill-f32.wat b/tests/disas/array-fill-f32.wat index 9f1b4059065f..bb7042de5fc0 100644 --- a/tests/disas/array-fill-f32.wat +++ b/tests/disas/array-fill-f32.wat @@ -21,7 +21,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -79,7 +79,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -127,7 +127,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/array-fill-f64.wat b/tests/disas/array-fill-f64.wat index 6d54d4b3afe0..ca263d159529 100644 --- a/tests/disas/array-fill-f64.wat +++ b/tests/disas/array-fill-f64.wat @@ -21,7 +21,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -79,7 +79,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -127,7 +127,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/array-fill-funcref.wat b/tests/disas/array-fill-funcref.wat index 481efba12468..fa6650c0f001 100644 --- a/tests/disas/array-fill-funcref.wat +++ b/tests/disas/array-fill-funcref.wat @@ -24,7 +24,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -86,7 +86,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -149,7 +149,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -217,7 +217,7 @@ ;; function u0:3(i64 vmctx, i64) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/array-fill-i16.wat b/tests/disas/array-fill-i16.wat index 8961994fe0fc..4a7f06872abc 100644 --- a/tests/disas/array-fill-i16.wat +++ b/tests/disas/array-fill-i16.wat @@ -25,7 +25,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -83,7 +83,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -131,7 +131,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -179,7 +179,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/array-fill-i31ref.wat b/tests/disas/array-fill-i31ref.wat index a7234826ee2b..f1d6ef1fd01e 100644 --- a/tests/disas/array-fill-i31ref.wat +++ b/tests/disas/array-fill-i31ref.wat @@ -21,7 +21,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -79,7 +79,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -139,7 +139,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/array-fill-i32.wat b/tests/disas/array-fill-i32.wat index 61e2dba306e8..ad54e2f47163 100644 --- a/tests/disas/array-fill-i32.wat +++ b/tests/disas/array-fill-i32.wat @@ -25,7 +25,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -83,7 +83,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -131,7 +131,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -179,7 +179,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/array-fill-i64.wat b/tests/disas/array-fill-i64.wat index 45ca936020e9..155999b76fe2 100644 --- a/tests/disas/array-fill-i64.wat +++ b/tests/disas/array-fill-i64.wat @@ -25,7 +25,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -83,7 +83,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -131,7 +131,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -179,7 +179,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/basic-wat-test.wat b/tests/disas/basic-wat-test.wat index c1beabd150ca..479f0e3c5505 100644 --- a/tests/disas/basic-wat-test.wat +++ b/tests/disas/basic-wat-test.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/bounds-check.wat b/tests/disas/bounds-check.wat index 9799683624e4..9d0f2645625d 100644 --- a/tests/disas/bounds-check.wat +++ b/tests/disas/bounds-check.wat @@ -28,7 +28,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/br_table.wat b/tests/disas/br_table.wat index 5fe7fc640db0..2c3454684039 100644 --- a/tests/disas/br_table.wat +++ b/tests/disas/br_table.wat @@ -34,7 +34,7 @@ ;; function u0:0(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -71,7 +71,7 @@ ;; function u0:1(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -108,7 +108,7 @@ ;; function u0:2(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -133,7 +133,7 @@ ;; function u0:3(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/branch-hinting-disabled.wat b/tests/disas/branch-hinting-disabled.wat index dcd84b76b1eb..28f818a124ac 100644 --- a/tests/disas/branch-hinting-disabled.wat +++ b/tests/disas/branch-hinting-disabled.wat @@ -30,7 +30,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -55,7 +55,7 @@ ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/branch-hinting.wat b/tests/disas/branch-hinting.wat index 8647afba3fb8..602317a28681 100644 --- a/tests/disas/branch-hinting.wat +++ b/tests/disas/branch-hinting.wat @@ -75,7 +75,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -97,7 +97,7 @@ ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -119,7 +119,7 @@ ;; function u0:2(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -144,7 +144,7 @@ ;; function u0:3(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -170,7 +170,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1879048192 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; stack_limit = gv2 diff --git a/tests/disas/byteswap.wat b/tests/disas/byteswap.wat index 8ea048c782c9..f5b7bae454f3 100644 --- a/tests/disas/byteswap.wat +++ b/tests/disas/byteswap.wat @@ -74,7 +74,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -89,7 +89,7 @@ ;; function u0:1(i64 vmctx, i64, i64) -> i64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/call-indirect-with-gc.wat b/tests/disas/call-indirect-with-gc.wat index 559ba6919366..2c17443a6960 100644 --- a/tests/disas/call-indirect-with-gc.wat +++ b/tests/disas/call-indirect-with-gc.wat @@ -14,7 +14,7 @@ ;; region1 = 1073741824 "PublicTable" ;; region2 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+48 diff --git a/tests/disas/call-indirect-without-gc.wat b/tests/disas/call-indirect-without-gc.wat index 87d47eee0ff6..93e0181b0c92 100644 --- a/tests/disas/call-indirect-without-gc.wat +++ b/tests/disas/call-indirect-without-gc.wat @@ -14,7 +14,7 @@ ;; region1 = 1073741824 "PublicTable" ;; region2 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+48 diff --git a/tests/disas/call-indirect.wat b/tests/disas/call-indirect.wat index 6c625e396a39..23c55f5a9897 100644 --- a/tests/disas/call-indirect.wat +++ b/tests/disas/call-indirect.wat @@ -12,7 +12,7 @@ ;; region1 = 1073741824 "PublicTable" ;; region2 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+48 diff --git a/tests/disas/call-simd.wat b/tests/disas/call-simd.wat index 6cee02b809be..fd0c88827872 100644 --- a/tests/disas/call-simd.wat +++ b/tests/disas/call-simd.wat @@ -18,7 +18,7 @@ ;; function u0:0(i64 vmctx, i64) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i64, i8x16, i8x16) -> i8x16 tail ;; fn0 = colocated u0:1 sig0 @@ -38,7 +38,7 @@ ;; function u0:1(i64 vmctx, i64, i8x16, i8x16) -> i8x16 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/call.wat b/tests/disas/call.wat index 5e403570109a..31cb945c5c91 100644 --- a/tests/disas/call.wat +++ b/tests/disas/call.wat @@ -14,7 +14,7 @@ ;; function u0:0(i64 vmctx, i64) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i64) -> i32 tail ;; fn0 = colocated u0:1 sig0 @@ -33,7 +33,7 @@ ;; function u0:1(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/component-model/checked-intrinsics-inlined-no-spectre.wat b/tests/disas/component-model/checked-intrinsics-inlined-no-spectre.wat index ff4cabd0e5e4..12c8c373ef85 100644 --- a/tests/disas/component-model/checked-intrinsics-inlined-no-spectre.wat +++ b/tests/disas/component-model/checked-intrinsics-inlined-no-spectre.wat @@ -54,9 +54,8 @@ ;; region3 = 104 "VMContext+0x68" ;; region4 = 136 "VMContext+0x88" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 -;; gv3 = vmctx ;; sig0 = (i64 vmctx, i64) -> i64 tail ;; sig1 = (i64 vmctx, i64, i64, i64, i64) -> i32 tail ;; sig2 = (i64 vmctx, i64, i64, i64, i64, i32) tail @@ -66,22 +65,22 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i64, v3: i64): -;; @01b0 v11 = iconst.i64 4 -;; @01b0 v12, v13 = uadd_overflow v2, v11 ; v11 = 4 -;; @01b0 v14 = icmp ugt v12, v3 -;; @01b0 v15 = bor v13, v14 -;; @01b0 trapnz v15, heap_oob -;; @01aa v7 = load.i64 notrap aligned readonly can_move region0 v0+8 -;; @01aa v8 = load.i64 notrap aligned readonly can_move region2 v7+104 -;; @01b0 v16 = iadd v8, v2 -;; @01b0 v17 = load.i32 notrap aligned v16 -;; @01bf v27, v28 = uadd_overflow v2, v11 ; v11 = 4 -;; @01bf v29 = icmp ugt v27, v3 -;; @01bf v30 = bor v28, v29 -;; @01bf trapnz v30, heap_oob -;; @01bc v22 = iconst.i32 1 -;; @01be v23 = iadd v17, v22 ; v22 = 1 -;; @01bf store notrap aligned v23, v16 +;; @01b0 v9 = iconst.i64 4 +;; @01b0 v10, v11 = uadd_overflow v2, v9 ; v9 = 4 +;; @01b0 v12 = icmp ugt v10, v3 +;; @01b0 v13 = bor v11, v12 +;; @01b0 trapnz v13, heap_oob +;; @01aa v6 = load.i64 notrap aligned readonly can_move region0 v0+8 +;; @01aa v7 = load.i64 notrap aligned readonly can_move region2 v6+104 +;; @01b0 v14 = iadd v7, v2 +;; @01b0 v15 = load.i32 notrap aligned v14 +;; @01bf v23, v24 = uadd_overflow v2, v9 ; v9 = 4 +;; @01bf v25 = icmp ugt v23, v3 +;; @01bf v26 = bor v24, v25 +;; @01bf trapnz v26, heap_oob +;; @01bc v19 = iconst.i32 1 +;; @01be v20 = iadd v15, v19 ; v19 = 1 +;; @01bf store notrap aligned v20, v14 ;; @01c1 jump block1 ;; ;; block1: diff --git a/tests/disas/component-model/checked-intrinsics-inlined.wat b/tests/disas/component-model/checked-intrinsics-inlined.wat index b32dc63354be..b577898856f7 100644 --- a/tests/disas/component-model/checked-intrinsics-inlined.wat +++ b/tests/disas/component-model/checked-intrinsics-inlined.wat @@ -55,9 +55,8 @@ ;; region3 = 104 "VMContext+0x68" ;; region4 = 136 "VMContext+0x88" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 -;; gv3 = vmctx ;; sig0 = (i64 vmctx, i64) -> i64 tail ;; sig1 = (i64 vmctx, i64, i64, i64, i64) -> i32 tail ;; sig2 = (i64 vmctx, i64, i64, i64, i64, i32) tail @@ -67,25 +66,25 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i64, v3: i64): -;; @01b0 v11 = iconst.i64 4 -;; @01b0 v12, v13 = uadd_overflow v2, v11 ; v11 = 4 -;; @01b0 v14 = icmp ugt v12, v3 -;; @01b0 v15 = bor v13, v14 -;; @01b0 v17 = iconst.i64 0 -;; @01aa v7 = load.i64 notrap aligned readonly can_move region0 v0+8 -;; @01aa v8 = load.i64 notrap aligned readonly can_move region2 v7+104 -;; @01b0 v16 = iadd v8, v2 -;; @01b0 v18 = select_spectre_guard v15, v17, v16 ; v17 = 0 -;; @01b0 trapz v18, heap_oob -;; @01b0 v19 = load.i32 notrap aligned v18 -;; @01bf v29, v30 = uadd_overflow v2, v11 ; v11 = 4 -;; @01bf v31 = icmp ugt v29, v3 -;; @01bf v32 = bor v30, v31 -;; @01bf v35 = select_spectre_guard v32, v17, v16 ; v17 = 0 -;; @01bf trapz v35, heap_oob -;; @01bc v24 = iconst.i32 1 -;; @01be v25 = iadd v19, v24 ; v24 = 1 -;; @01bf store notrap aligned v25, v35 +;; @01b0 v9 = iconst.i64 4 +;; @01b0 v10, v11 = uadd_overflow v2, v9 ; v9 = 4 +;; @01b0 v12 = icmp ugt v10, v3 +;; @01b0 v13 = bor v11, v12 +;; @01b0 v15 = iconst.i64 0 +;; @01aa v6 = load.i64 notrap aligned readonly can_move region0 v0+8 +;; @01aa v7 = load.i64 notrap aligned readonly can_move region2 v6+104 +;; @01b0 v14 = iadd v7, v2 +;; @01b0 v16 = select_spectre_guard v13, v15, v14 ; v15 = 0 +;; @01b0 trapz v16, heap_oob +;; @01b0 v17 = load.i32 notrap aligned v16 +;; @01bf v25, v26 = uadd_overflow v2, v9 ; v9 = 4 +;; @01bf v27 = icmp ugt v25, v3 +;; @01bf v28 = bor v26, v27 +;; @01bf v31 = select_spectre_guard v28, v15, v14 ; v15 = 0 +;; @01bf trapz v31, heap_oob +;; @01bc v21 = iconst.i32 1 +;; @01be v22 = iadd v17, v21 ; v21 = 1 +;; @01bf store notrap aligned v22, v31 ;; @01c1 jump block1 ;; ;; block1: diff --git a/tests/disas/component-model/direct-adapter-calls-inlining.wat b/tests/disas/component-model/direct-adapter-calls-inlining.wat index cabaa03df885..d30057bb339e 100644 --- a/tests/disas/component-model/direct-adapter-calls-inlining.wat +++ b/tests/disas/component-model/direct-adapter-calls-inlining.wat @@ -63,18 +63,17 @@ ;; region5 = 104 "VMContext+0x68" ;; region6 = 88 "VMContext+0x58" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx -;; gv4 = vmctx -;; gv5 = load.i64 notrap aligned readonly region0 gv4+8 -;; gv6 = load.i64 notrap aligned gv5+24 -;; gv7 = vmctx -;; gv8 = load.i64 notrap aligned readonly can_move region2 gv7+136 -;; gv9 = load.i64 notrap aligned readonly can_move region3 gv7+112 -;; gv10 = vmctx -;; gv11 = load.i64 notrap aligned readonly region0 gv10+8 -;; gv12 = load.i64 notrap aligned gv11+24 +;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 +;; gv5 = load.i64 notrap aligned gv4+24 +;; gv6 = vmctx +;; gv7 = load.i64 notrap aligned readonly can_move region2 gv6+136 +;; gv8 = load.i64 notrap aligned readonly can_move region3 gv6+112 +;; gv9 = vmctx +;; gv10 = load.i64 notrap aligned readonly can_move region0 gv9+8 +;; gv11 = load.i64 notrap aligned gv10+24 ;; sig0 = (i64 vmctx, i64, i32) -> i32 tail ;; sig1 = (i64 vmctx, i64, i32) tail ;; sig2 = (i64 vmctx, i64, i32) -> i32 tail @@ -88,37 +87,37 @@ ;; block2: ;; jump block6 ;; -;; block8(v10: i64): +;; block8(v9: i64): ;; jump block5 ;; ;; block6: -;; @00ee v5 = load.i64 notrap aligned readonly can_move region1 v0+72 -;; v15 = load.i64 notrap aligned readonly can_move region2 v5+136 -;; v16 = load.i32 notrap aligned region4 v15 -;; v17 = iconst.i32 1 -;; v18 = band v16, v17 ; v17 = 1 -;; v14 = iconst.i32 0 -;; v20 = icmp eq v18, v14 ; v14 = 0 -;; brif v20, block9, block10 +;; @00ee v4 = load.i64 notrap aligned readonly can_move region1 v0+72 +;; v14 = load.i64 notrap aligned readonly can_move region2 v4+136 +;; v15 = load.i32 notrap aligned region4 v14 +;; v16 = iconst.i32 1 +;; v17 = band v15, v16 ; v16 = 1 +;; v13 = iconst.i32 0 +;; v19 = icmp eq v17, v13 ; v13 = 0 +;; brif v19, block9, block10 ;; ;; block9: -;; v24 = load.i64 notrap aligned readonly can_move region6 v5+88 -;; v23 = load.i64 notrap aligned readonly can_move region5 v5+104 -;; v22 = iconst.i32 23 -;; try_call_indirect v24(v23, v5, v22), sig1, block11, [ context v5, default: block8(exn0) ] ; v22 = 23 +;; v23 = load.i64 notrap aligned readonly can_move region6 v4+88 +;; v22 = load.i64 notrap aligned readonly can_move region5 v4+104 +;; v21 = iconst.i32 23 +;; try_call_indirect v23(v22, v4, v21), sig1, block11, [ context v4, default: block8(exn0) ] ; v21 = 23 ;; ;; block11: ;; trap user12 ;; ;; block10: -;; v29 = load.i64 notrap aligned readonly can_move region3 v5+112 -;; v30 = load.i32 notrap aligned region4 v29 -;; v31 = iconst.i32 -2 -;; v32 = band v30, v31 ; v31 = -2 -;; store notrap aligned region4 v32, v29 -;; v62 = iconst.i32 1 -;; v63 = bor v30, v62 ; v62 = 1 -;; store notrap aligned region4 v63, v29 +;; v28 = load.i64 notrap aligned readonly can_move region3 v4+112 +;; v29 = load.i32 notrap aligned region4 v28 +;; v30 = iconst.i32 -2 +;; v31 = band v29, v30 ; v30 = -2 +;; store notrap aligned region4 v31, v28 +;; v61 = iconst.i32 1 +;; v62 = bor v29, v61 ; v61 = 1 +;; store notrap aligned region4 v62, v28 ;; jump block13 ;; ;; block13: @@ -128,21 +127,21 @@ ;; jump block12 ;; ;; block12: -;; v43 = load.i32 notrap aligned region4 v15 -;; v64 = iconst.i32 -2 -;; v65 = band v43, v64 ; v64 = -2 -;; store notrap aligned region4 v65, v15 -;; v66 = iconst.i32 1 -;; v67 = bor v43, v66 ; v66 = 1 -;; store notrap aligned region4 v67, v15 +;; v42 = load.i32 notrap aligned region4 v14 +;; v63 = iconst.i32 -2 +;; v64 = band v42, v63 ; v63 = -2 +;; store notrap aligned region4 v64, v14 +;; v65 = iconst.i32 1 +;; v66 = bor v42, v65 ; v65 = 1 +;; store notrap aligned region4 v66, v14 ;; jump block7 ;; ;; block7: ;; jump block4 ;; ;; block5: -;; v26 = iconst.i32 49 -;; call_indirect.i64 sig1, v24(v23, v5, v26) ; v26 = 49 +;; v25 = iconst.i32 49 +;; call_indirect.i64 sig1, v23(v22, v4, v25) ; v25 = 49 ;; trap user12 ;; ;; block4: @@ -155,6 +154,6 @@ ;; @00f0 jump block1 ;; ;; block1: -;; v54 = iconst.i32 1276 -;; @00f0 return v54 ; v54 = 1276 +;; v53 = iconst.i32 1276 +;; @00f0 return v53 ; v53 = 1276 ;; } diff --git a/tests/disas/component-model/direct-adapter-calls.wat b/tests/disas/component-model/direct-adapter-calls.wat index 83cc2125936e..ff2e9de64246 100644 --- a/tests/disas/component-model/direct-adapter-calls.wat +++ b/tests/disas/component-model/direct-adapter-calls.wat @@ -60,7 +60,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -77,21 +77,20 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 72 "VMContext+0x48" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 -;; gv3 = vmctx ;; sig0 = (i64 vmctx, i64, i32) -> i32 tail ;; fn0 = colocated u2:0 sig0 ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64): -;; @00ee v5 = load.i64 notrap aligned readonly can_move region1 v0+72 +;; @00ee v4 = load.i64 notrap aligned readonly can_move region1 v0+72 ;; @00eb v3 = iconst.i32 1234 -;; @00ee v6 = call fn0(v5, v0, v3) ; v3 = 1234 +;; @00ee v5 = call fn0(v4, v0, v3) ; v3 = 1234 ;; @00f0 jump block1 ;; ;; block1: -;; @00f0 return v6 +;; @00f0 return v5 ;; } ;; ;; function u2:0(i64 vmctx, i64, i32) -> i32 tail { @@ -103,7 +102,7 @@ ;; region5 = 112 "VMContext+0x70" ;; region6 = 72 "VMContext+0x48" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region1 gv3+136 @@ -129,44 +128,44 @@ ;; @0086 brif v14, block7, block8 ;; ;; block7: -;; @008a v19 = load.i64 notrap aligned readonly can_move region4 v0+88 -;; @008a v18 = load.i64 notrap aligned readonly can_move region3 v0+104 +;; @008a v18 = load.i64 notrap aligned readonly can_move region4 v0+88 +;; @008a v17 = load.i64 notrap aligned readonly can_move region3 v0+104 ;; @0088 v16 = iconst.i32 23 -;; @008a try_call_indirect v19(v18, v0, v16), sig0, block9, [ context v0, default: block6(exn0) ] ; v16 = 23 +;; @008a try_call_indirect v18(v17, v0, v16), sig0, block9, [ context v0, default: block6(exn0) ] ; v16 = 23 ;; ;; block9: ;; @008c trap user12 ;; ;; block8: -;; @008e v20 = load.i64 notrap aligned readonly can_move region5 v0+112 -;; @008e v21 = load.i32 notrap aligned region2 v20 -;; @0090 v22 = iconst.i32 -2 -;; @0092 v23 = band v21, v22 ; v22 = -2 -;; @0093 store notrap aligned region2 v23, v20 -;; v60 = iconst.i32 1 -;; v61 = bor v21, v60 ; v60 = 1 -;; @009c store notrap aligned region2 v61, v20 -;; @009e v31 = load.i64 notrap aligned readonly can_move region6 v0+72 -;; @009e try_call fn0(v31, v0, v2), sig1, block10(ret0), [ context v0, default: block6(exn0) ] -;; -;; block10(v32: i32): -;; @00a2 v34 = load.i32 notrap aligned region2 v9 -;; v62 = iconst.i32 -2 -;; v63 = band v34, v62 ; v62 = -2 -;; @00a7 store notrap aligned region2 v63, v9 -;; v64 = iconst.i32 1 -;; v65 = bor v34, v64 ; v64 = 1 -;; @00b0 store notrap aligned region2 v65, v9 -;; @00b2 jump block5(v32) +;; @008e v19 = load.i64 notrap aligned readonly can_move region5 v0+112 +;; @008e v20 = load.i32 notrap aligned region2 v19 +;; @0090 v21 = iconst.i32 -2 +;; @0092 v22 = band v20, v21 ; v21 = -2 +;; @0093 store notrap aligned region2 v22, v19 +;; v57 = iconst.i32 1 +;; v58 = bor v20, v57 ; v57 = 1 +;; @009c store notrap aligned region2 v58, v19 +;; @009e v29 = load.i64 notrap aligned readonly can_move region6 v0+72 +;; @009e try_call fn0(v29, v0, v2), sig1, block10(ret0), [ context v0, default: block6(exn0) ] +;; +;; block10(v30: i32): +;; @00a2 v32 = load.i32 notrap aligned region2 v9 +;; v59 = iconst.i32 -2 +;; v60 = band v32, v59 ; v59 = -2 +;; @00a7 store notrap aligned region2 v60, v9 +;; v61 = iconst.i32 1 +;; v62 = bor v32, v61 ; v61 = 1 +;; @00b0 store notrap aligned region2 v62, v9 +;; @00b2 jump block5(v30) ;; ;; block5(v6: i32): ;; @00b3 jump block2(v6) ;; ;; block3: -;; v66 = load.i64 notrap aligned readonly can_move region4 v0+88 -;; v67 = load.i64 notrap aligned readonly can_move region3 v0+104 -;; @00b6 v43 = iconst.i32 49 -;; @00b8 call_indirect sig0, v66(v67, v0, v43) ; v43 = 49 +;; v63 = load.i64 notrap aligned readonly can_move region4 v0+88 +;; v64 = load.i64 notrap aligned readonly can_move region3 v0+104 +;; @00b6 v41 = iconst.i32 49 +;; @00b8 call_indirect sig0, v63(v64, v0, v41) ; v41 = 49 ;; @00ba trap user12 ;; ;; block2(v5: i32): diff --git a/tests/disas/component-model/exported-module-makes-adapters-indirect.wat b/tests/disas/component-model/exported-module-makes-adapters-indirect.wat index 94cea1efe4fd..3d1b0dd73f9d 100644 --- a/tests/disas/component-model/exported-module-makes-adapters-indirect.wat +++ b/tests/disas/component-model/exported-module-makes-adapters-indirect.wat @@ -63,19 +63,18 @@ ;; region1 = 72 "VMContext+0x48" ;; region2 = 56 "VMContext+0x38" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 -;; gv3 = vmctx ;; sig0 = (i64 vmctx, i64, i32) -> i32 tail ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64): -;; @00ee v6 = load.i64 notrap aligned readonly can_move region2 v0+56 -;; @00ee v5 = load.i64 notrap aligned readonly can_move region1 v0+72 +;; @00ee v5 = load.i64 notrap aligned readonly can_move region2 v0+56 +;; @00ee v4 = load.i64 notrap aligned readonly can_move region1 v0+72 ;; @00eb v3 = iconst.i32 1234 -;; @00ee v7 = call_indirect sig0, v6(v5, v0, v3) ; v3 = 1234 +;; @00ee v6 = call_indirect sig0, v5(v4, v0, v3) ; v3 = 1234 ;; @00f0 jump block1 ;; ;; block1: -;; @00f0 return v7 +;; @00f0 return v6 ;; } diff --git a/tests/disas/component-model/inlining-and-unsafe-intrinsics.wat b/tests/disas/component-model/inlining-and-unsafe-intrinsics.wat index c37473bded69..961a959d4490 100644 --- a/tests/disas/component-model/inlining-and-unsafe-intrinsics.wat +++ b/tests/disas/component-model/inlining-and-unsafe-intrinsics.wat @@ -49,9 +49,8 @@ ;; region3 = 104 "VMContext+0x68" ;; region4 = 136 "VMContext+0x88" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 -;; gv3 = vmctx ;; sig0 = (i64 vmctx, i64) -> i64 tail ;; sig1 = (i64 vmctx, i64, i64) -> i32 tail ;; sig2 = (i64 vmctx, i64, i64, i32) tail @@ -61,12 +60,12 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64): -;; @0153 v5 = load.i64 notrap aligned readonly can_move region0 v0+8 -;; @0153 v6 = load.i64 notrap aligned readonly can_move region2 v5+104 -;; @0155 v9 = load.i8 notrap aligned v6 -;; v22 = iconst.i8 1 -;; v23 = iadd v9, v22 ; v22 = 1 -;; @0160 store notrap aligned v23, v6 +;; @0153 v4 = load.i64 notrap aligned readonly can_move region0 v0+8 +;; @0153 v5 = load.i64 notrap aligned readonly can_move region2 v4+104 +;; @0155 v7 = load.i8 notrap aligned v5 +;; v18 = iconst.i8 1 +;; v19 = iadd v7, v18 ; v18 = 1 +;; @0160 store notrap aligned v19, v5 ;; @0162 jump block1 ;; ;; block1: diff --git a/tests/disas/component-model/inlining-bug.wat b/tests/disas/component-model/inlining-bug.wat index 2bc13464b3d8..18cb7c65f6dc 100644 --- a/tests/disas/component-model/inlining-bug.wat +++ b/tests/disas/component-model/inlining-bug.wat @@ -39,16 +39,14 @@ ;; region1 = 72 "VMContext+0x48" ;; region2 = 104 "VMContext+0x68" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx -;; gv4 = vmctx -;; gv5 = load.i64 notrap aligned readonly region0 gv4+8 -;; gv6 = load.i64 notrap aligned gv5+24 -;; gv7 = vmctx -;; gv8 = vmctx -;; gv9 = load.i64 notrap aligned readonly region0 gv8+8 -;; gv10 = load.i64 notrap aligned gv9+24 +;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 +;; gv5 = load.i64 notrap aligned gv4+24 +;; gv6 = vmctx +;; gv7 = load.i64 notrap aligned readonly can_move region0 gv6+8 +;; gv8 = load.i64 notrap aligned gv7+24 ;; sig0 = (i64 vmctx, i64) -> i32 tail ;; sig1 = (i64 vmctx, i64) -> i32 tail ;; sig2 = (i64 vmctx, i64) tail @@ -64,9 +62,9 @@ ;; jump block4 ;; ;; block4: -;; @00d4 v4 = load.i64 notrap aligned readonly can_move region1 v0+72 -;; v10 = load.i64 notrap aligned readonly can_move region2 v4+104 -;; call fn2(v10, v10) +;; @00d4 v3 = load.i64 notrap aligned readonly can_move region1 v0+72 +;; v9 = load.i64 notrap aligned readonly can_move region2 v3+104 +;; call fn2(v9, v9) ;; jump block5 ;; ;; block5: @@ -82,6 +80,6 @@ ;; @00d6 jump block1 ;; ;; block1: -;; v11 = iconst.i32 1 -;; @00d6 return v11 ; v11 = 1 +;; v10 = iconst.i32 1 +;; @00d6 return v10 ; v10 = 1 ;; } diff --git a/tests/disas/component-model/inlining-fuzz-bug.wat b/tests/disas/component-model/inlining-fuzz-bug.wat index 28a34d50fb86..c06a2f053e32 100644 --- a/tests/disas/component-model/inlining-fuzz-bug.wat +++ b/tests/disas/component-model/inlining-fuzz-bug.wat @@ -42,19 +42,17 @@ ;; region1 = 72 "VMContext+0x48" ;; region2 = 104 "VMContext+0x68" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx -;; gv4 = vmctx -;; gv5 = load.i64 notrap aligned readonly region0 gv4+8 -;; gv6 = load.i64 notrap aligned gv5+24 -;; gv7 = vmctx -;; gv8 = vmctx -;; gv9 = load.i64 notrap aligned readonly region0 gv8+8 -;; gv10 = load.i64 notrap aligned gv9+24 -;; gv11 = vmctx -;; gv12 = load.i64 notrap aligned readonly region0 gv11+8 -;; gv13 = load.i64 notrap aligned gv12+24 +;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 +;; gv5 = load.i64 notrap aligned gv4+24 +;; gv6 = vmctx +;; gv7 = load.i64 notrap aligned readonly can_move region0 gv6+8 +;; gv8 = load.i64 notrap aligned gv7+24 +;; gv9 = vmctx +;; gv10 = load.i64 notrap aligned readonly can_move region0 gv9+8 +;; gv11 = load.i64 notrap aligned gv10+24 ;; sig0 = (i64 vmctx, i64) -> i32 tail ;; sig1 = (i64 vmctx, i64) -> i32 tail ;; fn0 = colocated u1:0 sig0 @@ -93,6 +91,6 @@ ;; @00c6 jump block1 ;; ;; block1: -;; v25 = iconst.i32 301 -;; @00c6 return v25 ; v25 = 301 +;; v24 = iconst.i32 301 +;; @00c6 return v24 ; v24 = 301 ;; } diff --git a/tests/disas/component-model/issue-11458.wat b/tests/disas/component-model/issue-11458.wat index c783a4cbffb5..b2f0d2c35b13 100644 --- a/tests/disas/component-model/issue-11458.wat +++ b/tests/disas/component-model/issue-11458.wat @@ -23,12 +23,11 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 72 "VMContext+0x48" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx -;; gv4 = vmctx -;; gv5 = load.i64 notrap aligned readonly region0 gv4+8 -;; gv6 = load.i64 notrap aligned gv5+24 +;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 +;; gv5 = load.i64 notrap aligned gv4+24 ;; sig0 = (i64 vmctx, i64, i32) -> i32 tail ;; sig1 = (i64 vmctx, i64, i32) -> i32 tail ;; fn0 = colocated u0:0 sig0 @@ -39,14 +38,14 @@ ;; @006f jump block2 ;; ;; block2: -;; @006f v6 = load.i64 notrap aligned readonly can_move region1 v0+72 -;; v10 = iconst.i32 1 -;; v12 = call fn1(v6, v6, v10) ; v10 = 1 +;; @006f v5 = load.i64 notrap aligned readonly can_move region1 v0+72 +;; v9 = iconst.i32 1 +;; v11 = call fn1(v5, v5, v9) ; v9 = 1 ;; jump block4 ;; ;; block4: ;; @0071 jump block1 ;; ;; block1: -;; @0071 return v12 +;; @0071 return v11 ;; } diff --git a/tests/disas/component-model/multiple-instantiations-makes-adapters-indirect.wat b/tests/disas/component-model/multiple-instantiations-makes-adapters-indirect.wat index 7710674c0644..fe05bc97a067 100644 --- a/tests/disas/component-model/multiple-instantiations-makes-adapters-indirect.wat +++ b/tests/disas/component-model/multiple-instantiations-makes-adapters-indirect.wat @@ -69,19 +69,18 @@ ;; region1 = 72 "VMContext+0x48" ;; region2 = 56 "VMContext+0x38" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 -;; gv3 = vmctx ;; sig0 = (i64 vmctx, i64, i32) -> i32 tail ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64): -;; @00ee v6 = load.i64 notrap aligned readonly can_move region2 v0+56 -;; @00ee v5 = load.i64 notrap aligned readonly can_move region1 v0+72 +;; @00ee v5 = load.i64 notrap aligned readonly can_move region2 v0+56 +;; @00ee v4 = load.i64 notrap aligned readonly can_move region1 v0+72 ;; @00eb v3 = iconst.i32 1234 -;; @00ee v7 = call_indirect sig0, v6(v5, v0, v3) ; v3 = 1234 +;; @00ee v6 = call_indirect sig0, v5(v4, v0, v3) ; v3 = 1234 ;; @00f0 jump block1 ;; ;; block1: -;; @00f0 return v7 +;; @00f0 return v6 ;; } diff --git a/tests/disas/conditional-traps.wat b/tests/disas/conditional-traps.wat index 583b6fadcf21..46c0821716f8 100644 --- a/tests/disas/conditional-traps.wat +++ b/tests/disas/conditional-traps.wat @@ -24,7 +24,7 @@ ;; function u0:0(i64 vmctx, i64, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -42,7 +42,7 @@ ;; function u0:1(i64 vmctx, i64, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/dead-code.wat b/tests/disas/dead-code.wat index 678c39641a90..0a65640e4aa7 100644 --- a/tests/disas/dead-code.wat +++ b/tests/disas/dead-code.wat @@ -24,7 +24,7 @@ ;; function u0:0(i64 vmctx, i64, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -50,7 +50,7 @@ ;; function u0:1(i64 vmctx, i64, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -64,7 +64,7 @@ ;; function u0:2(i64 vmctx, i64) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -78,7 +78,7 @@ ;; function u0:3(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/debug-exceptions.wat b/tests/disas/debug-exceptions.wat index 7ce7f35decae..c903d304a57e 100644 --- a/tests/disas/debug-exceptions.wat +++ b/tests/disas/debug-exceptions.wat @@ -27,113 +27,112 @@ ;; stp d8, d9, [sp, #-0x10]! ;; sub sp, sp, #0x20 ;; ldr x0, [x2, #8] -;; ldr x0, [x0, #0x18] -;; mov x1, sp -;; cmp x1, x0 -;; b.lo #0x224 -;; 44: stur x2, [sp] +;; ldr x1, [x0, #0x18] +;; stur x0, [sp, #0x18] +;; mov x0, sp +;; cmp x0, x1 +;; b.lo #0x21c +;; 48: stur x2, [sp] ;; mov x0, x2 ;; stur x2, [sp, #0x10] ;; nop ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x35, slot at FP-0xb0, locals , stack -;; ╰─╼ breakpoint patch: wasm PC 0x35, patch bytes [71, 1, 0, 148] +;; ╰─╼ breakpoint patch: wasm PC 0x35, patch bytes [61, 1, 0, 148] ;; ldur x0, [sp, #0x10] ;; nop ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x37, slot at FP-0xb0, locals , stack -;; ╰─╼ breakpoint patch: wasm PC 0x37, patch bytes [69, 1, 0, 148] +;; ╰─╼ breakpoint patch: wasm PC 0x37, patch bytes [59, 1, 0, 148] ;; ldur x0, [sp, #0x10] ;; nop ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x3d, slot at FP-0xb0, locals , stack -;; ╰─╼ breakpoint patch: wasm PC 0x3d, patch bytes [67, 1, 0, 148] +;; ╰─╼ breakpoint patch: wasm PC 0x3d, patch bytes [57, 1, 0, 148] ;; mov w1, #0x2a ;; stur w1, [sp, #8] ;; nop ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x3f, slot at FP-0xb0, locals , stack I32 @ slot+0x8 -;; ╰─╼ breakpoint patch: wasm PC 0x3f, patch bytes [64, 1, 0, 148] +;; ╰─╼ breakpoint patch: wasm PC 0x3f, patch bytes [54, 1, 0, 148] ;; nop ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x40, slot at FP-0xb0, locals , stack -;; ╰─╼ breakpoint patch: wasm PC 0x40, patch bytes [63, 1, 0, 148] +;; ╰─╼ breakpoint patch: wasm PC 0x40, patch bytes [53, 1, 0, 148] ;; stur w1, [sp, #8] ;; nop ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x42, slot at FP-0xb0, locals , stack I32 @ slot+0x8 -;; ╰─╼ breakpoint patch: wasm PC 0x42, patch bytes [61, 1, 0, 148] +;; ╰─╼ breakpoint patch: wasm PC 0x42, patch bytes [51, 1, 0, 148] ;; ldur x2, [sp, #0x10] -;; bl #0x4cc -;; 84: ldur x0, [sp, #0x10] +;; bl #0x4b0 +;; 88: ldur x0, [sp, #0x10] ;; mov x19, x2 -;; ldr x4, [x0, #0x20] -;; ldr w3, [x4] -;; mov w5, w3 -;; add x5, x5, #0x20 -;; ldr w6, [x4, #4] -;; cmp x5, x6 -;; b.hi #0x1b8 -;; a8: add w7, w3, #0x20 -;; str w7, [x4] -;; mov w9, #2 -;; movk w9, #0x400, lsl #16 +;; ldr x1, [x0, #0x20] +;; ldr w3, [x1] +;; mov w2, w3 +;; add x2, x2, #0x20 +;; ldr w4, [x1, #4] +;; cmp x2, x4 +;; b.hi #0x1b4 +;; ac: ldur x0, [sp, #0x18] +;; add w4, w3, #0x20 +;; str w4, [x1] +;; mov w6, #2 +;; movk w6, #0x400, lsl #16 +;; ldr x5, [x0, #0x20] +;; add x1, x5, w3, uxtw +;; str w6, [x5, w3, uxtw] ;; ldur x0, [sp, #0x10] -;; ldr x8, [x0, #8] -;; ldr x8, [x8, #0x20] -;; add x0, x8, w3, uxtw -;; str w9, [x8, w3, uxtw] -;; ldur x1, [sp, #0x10] -;; ldr x9, [x1, #0x28] -;; ldr w9, [x9, #8] -;; add x10, x8, #4 -;; str w9, [x10, w3, uxtw] -;; mov x10, #0x20 -;; add x11, x8, #8 -;; str w10, [x11, w3, uxtw] -;; mov w12, #0x2a -;; str w12, [x0, #0x18] +;; ldr x6, [x0, #0x28] +;; ldr w6, [x6, #8] +;; add x7, x5, #4 +;; str w6, [x7, w3, uxtw] +;; mov x7, #0x20 +;; add x8, x5, #8 +;; str w7, [x8, w3, uxtw] +;; mov w9, #0x2a +;; str w9, [x1, #0x18] ;; mov x2, x19 -;; str w2, [x0, #0x10] -;; mov w14, #0 -;; str w14, [x0, #0x14] +;; str w2, [x1, #0x10] +;; mov w11, #0 +;; str w11, [x1, #0x14] ;; ldur x2, [sp, #0x10] -;; bl #0x504 +;; bl #0x4e8 ;; ├─╼ exception frame offset: SP = FP - 0xb0 ;; ╰─╼ exception handler: tag=0, context at [SP+0x10], handler=0x124 ;; 10c: mov w3, #9 ;; ldur x2, [sp, #0x10] -;; bl #0x460 +;; bl #0x444 ;; 118: ldur x2, [sp, #0x10] -;; bl #0x498 +;; bl #0x47c ;; ╰─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x42, slot at FP-0xb0, locals , stack I32 @ slot+0x8 ;; 120: udf #0xc11f ;; mov w1, w0 ;; mov x2, #0x20 -;; adds x1, x1, x2 -;; cset x2, hs -;; tst w2, #0xff -;; b.ne #0x20c -;; 13c: ldur x14, [sp, #0x10] -;; ldr x2, [x14, #8] -;; ldr x3, [x2, #0x28] -;; cmp x1, x3 -;; b.hi #0x1f4 -;; 150: ldr x1, [x2, #0x20] +;; adds x15, x1, x2 +;; cset x1, hs +;; tst w1, #0xff +;; b.ne #0x204 +;; 13c: ldur x2, [sp, #0x18] +;; ldr x1, [x2, #0x28] +;; cmp x15, x1 +;; b.hi #0x1ec +;; 14c: ldr x1, [x2, #0x20] ;; add x1, x1, #0x18 ;; ldr w0, [x1, w0, uxtw] ;; stur w0, [sp, #8] ;; ldur x0, [sp, #0x10] ;; nop ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x48, slot at FP-0xb0, locals , stack I32 @ slot+0x8 -;; ╰─╼ breakpoint patch: wasm PC 0x48, patch bytes [2, 1, 0, 148] +;; ╰─╼ breakpoint patch: wasm PC 0x48, patch bytes [250, 0, 0, 148] ;; ldur x1, [sp, #0x10] ;; ldr x0, [x1, #0x38] ;; ldr x2, [x1, #0x48] ;; ldur x3, [sp, #0x10] ;; blr x0 ;; ╰─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x4a, slot at FP-0xb0, locals , stack I32 @ slot+0x8 -;; 17c: ldur x0, [sp, #0x10] +;; 178: ldur x0, [sp, #0x10] ;; nop ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x4a, slot at FP-0xb0, locals , stack I32 @ slot+0x8 -;; ╰─╼ breakpoint patch: wasm PC 0x4a, patch bytes [251, 0, 0, 148] +;; ╰─╼ breakpoint patch: wasm PC 0x4a, patch bytes [243, 0, 0, 148] ;; nop ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x4b, slot at FP-0xb0, locals , stack -;; ╰─╼ breakpoint patch: wasm PC 0x4b, patch bytes [250, 0, 0, 148] +;; ╰─╼ breakpoint patch: wasm PC 0x4b, patch bytes [242, 0, 0, 148] ;; add sp, sp, #0x20 ;; ldp d8, d9, [sp], #0x10 ;; ldp d10, d11, [sp], #0x10 @@ -146,39 +145,38 @@ ;; ldp x27, x28, [sp], #0x10 ;; ldp x29, x30, [sp], #0x10 ;; ret -;; 1b8: mov w3, #2 -;; 1bc: movk w3, #0x400, lsl #16 -;; 1c0: ldur x0, [sp, #0x10] -;; 1c4: ldr x6, [x0, #0x28] -;; 1c8: ldr w4, [x6, #8] -;; 1cc: mov w5, #0x20 -;; 1d0: mov w6, #0x10 -;; 1d4: ldur x2, [sp, #0x10] -;; 1d8: bl #0x3f0 -;; 1dc: ldur x0, [sp, #0x10] -;; 1e0: ldr x6, [x0, #8] -;; 1e4: ldr x6, [x6, #0x20] -;; 1e8: add x0, x6, w2, uxtw -;; 1ec: mov x3, x2 -;; 1f0: b #0xec -;; 1f4: mov w3, #0xfe +;; 1b4: mov w3, #2 +;; 1b8: movk w3, #0x400, lsl #16 +;; 1bc: ldur x0, [sp, #0x10] +;; 1c0: ldr x4, [x0, #0x28] +;; 1c4: ldr w4, [x4, #8] +;; 1c8: mov w5, #0x20 +;; 1cc: mov w6, #0x10 +;; 1d0: ldur x2, [sp, #0x10] +;; 1d4: bl #0x3dc +;; 1d8: ldur x0, [sp, #0x18] +;; 1dc: ldr x3, [x0, #0x20] +;; 1e0: add x1, x3, w2, uxtw +;; 1e4: mov x3, x2 +;; 1e8: b #0xec +;; 1ec: mov w3, #0xfe +;; 1f0: ldur x2, [sp, #0x10] +;; 1f4: bl #0x444 ;; 1f8: ldur x2, [sp, #0x10] -;; 1fc: bl #0x460 -;; 200: ldur x2, [sp, #0x10] -;; 204: bl #0x498 +;; 1fc: bl #0x47c ;; ╰─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x37, slot at FP-0xb0, locals , stack -;; 208: udf #0xc11f -;; 20c: mov w3, #0xfe +;; 200: udf #0xc11f +;; 204: mov w3, #0xfe +;; 208: ldur x2, [sp, #0x10] +;; 20c: bl #0x444 ;; 210: ldur x2, [sp, #0x10] -;; 214: bl #0x460 -;; 218: ldur x2, [sp, #0x10] -;; 21c: bl #0x498 +;; 214: bl #0x47c ;; ╰─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x37, slot at FP-0xb0, locals , stack -;; 220: udf #0xc11f -;; 224: stur x2, [sp, #0x10] -;; 228: mov w3, #0 -;; 22c: bl #0x460 -;; 230: ldur x2, [sp, #0x10] -;; 234: bl #0x498 +;; 218: udf #0xc11f +;; 21c: stur x2, [sp, #0x10] +;; 220: mov w3, #0 +;; 224: bl #0x444 +;; 228: ldur x2, [sp, #0x10] +;; 22c: bl #0x47c ;; ╰─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x34, slot at FP-0xb0, locals , stack -;; 238: udf #0xc11f +;; 230: udf #0xc11f diff --git a/tests/disas/debug.wat b/tests/disas/debug.wat index 4824e9493c62..abbcc23c973b 100644 --- a/tests/disas/debug.wat +++ b/tests/disas/debug.wat @@ -23,20 +23,20 @@ ;; 29: movq %rdi, (%rsp) ;; nopl (%rax, %rax) ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x24, slot at FP-0x30, locals I32 @ slot+0x8, I32 @ slot+0xc, stack -;; ╰─╼ breakpoint patch: wasm PC 0x24, patch bytes [232, 184, 1, 0, 0] +;; ╰─╼ breakpoint patch: wasm PC 0x24, patch bytes [232, 190, 1, 0, 0] ;; movl %edx, 0x10(%rsp) ;; nopl (%rax, %rax) ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x26, slot at FP-0x30, locals I32 @ slot+0x8, I32 @ slot+0xc, stack I32 @ slot+0x10 -;; ╰─╼ breakpoint patch: wasm PC 0x26, patch bytes [232, 175, 1, 0, 0] +;; ╰─╼ breakpoint patch: wasm PC 0x26, patch bytes [232, 181, 1, 0, 0] ;; movl %ecx, 0x14(%rsp) ;; nopl (%rax, %rax) ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x28, slot at FP-0x30, locals I32 @ slot+0x8, I32 @ slot+0xc, stack I32 @ slot+0x10, I32 @ slot+0x14 -;; ╰─╼ breakpoint patch: wasm PC 0x28, patch bytes [232, 166, 1, 0, 0] +;; ╰─╼ breakpoint patch: wasm PC 0x28, patch bytes [232, 172, 1, 0, 0] ;; leal (%rdx, %rcx), %eax ;; movl %eax, 0x10(%rsp) ;; nopl (%rax, %rax) ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x29, slot at FP-0x30, locals I32 @ slot+0x8, I32 @ slot+0xc, stack I32 @ slot+0x10 -;; ╰─╼ breakpoint patch: wasm PC 0x29, patch bytes [232, 154, 1, 0, 0] +;; ╰─╼ breakpoint patch: wasm PC 0x29, patch bytes [232, 160, 1, 0, 0] ;; movl %eax, 0x10(%rsp) ;; movq 0x20(%rsp), %r12 ;; addq $0x30, %rsp @@ -45,9 +45,9 @@ ;; retq ;; 62: movq %rdi, %r12 ;; 65: xorl %esi, %esi -;; 67: callq 0x18c +;; 67: callq 0x192 ;; 6c: movq %r12, %rdi -;; 6f: callq 0x1bd +;; 6f: callq 0x1c3 ;; ╰─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x23, slot at FP-0x30, locals I32 @ slot+0x8, I32 @ slot+0xc, stack ;; 74: ud2 ;; @@ -63,8 +63,8 @@ ;; movl (%rdx), %eax ;; movl 0x10(%rdx), %ecx ;; movq %rdx, (%rsp) -;; movq 8(%rdi), %r8 ;; movq %rbp, %r9 +;; movq 8(%rdi), %r8 ;; movq %r9, 0x48(%r8) ;; movq %rsp, %r9 ;; movq %r9, 0x40(%r8) @@ -102,13 +102,14 @@ ;; movq %rsp, %rbp ;; subq $0x30, %rsp ;; movq %rbx, 0x20(%rsp) +;; movq %r15, 0x28(%rsp) ;; movq %rdx, %r8 -;; movq 8(%rsi), %rax ;; movq %rbp, %rdx -;; movq %rdx, 0x30(%rax) -;; movq %rbp, %rdx -;; movq 8(%rdx), %rdx -;; movq %rdx, 0x38(%rax) +;; movq 8(%rsi), %r15 +;; movq %rdx, 0x30(%r15) +;; movq %rbp, %rax +;; movq 8(%rax), %rax +;; movq %rax, 0x38(%r15) ;; leaq (%rsp), %rdx ;; movq %r8, %rax ;; movl %eax, (%rsp) @@ -117,27 +118,27 @@ ;; movl $2, %ecx ;; movq %rsi, %rbx ;; callq *%rax -;; movq 8(%rbx), %rcx -;; addq $1, 0x10(%rcx) +;; addq $1, 0x10(%r15) ;; testb %al, %al -;; je 0x17a -;; 169: movl (%rsp), %eax +;; je 0x180 +;; 16a: movl (%rsp), %eax ;; movq 0x20(%rsp), %rbx +;; movq 0x28(%rsp), %r15 ;; addq $0x30, %rsp ;; movq %rbp, %rsp ;; popq %rbp ;; retq -;; 17a: movq 0x10(%rbx), %rax -;; 17e: movq 0x148(%rax), %rax -;; 185: movq %rbx, %rdi -;; 188: callq *%rax -;; 18a: ud2 +;; 180: movq 0x10(%rbx), %rax +;; 184: movq 0x148(%rax), %rax +;; 18b: movq %rbx, %rdi +;; 18e: callq *%rax +;; 190: ud2 ;; ;; wasmtime_builtin_trap: ;; pushq %rbp ;; movq %rsp, %rbp -;; movq 8(%rdi), %r9 ;; movq %rbp, %r10 +;; movq 8(%rdi), %r9 ;; movq %r10, 0x30(%r9) ;; movq %rbp, %r10 ;; movq 8(%r10), %r11 @@ -153,8 +154,8 @@ ;; wasmtime_builtin_raise: ;; pushq %rbp ;; movq %rsp, %rbp -;; movq 8(%rdi), %r8 ;; movq %rbp, %r9 +;; movq 8(%rdi), %r8 ;; movq %r9, 0x30(%r8) ;; movq %rbp, %r9 ;; movq 8(%r9), %r9 @@ -169,77 +170,78 @@ ;; wasmtime_patchable_builtin_breakpoint: ;; pushq %rbp ;; movq %rsp, %rbp -;; subq $0x150, %rsp +;; subq $0x160, %rsp ;; movq %rax, (%rsp) ;; movq %rcx, 8(%rsp) ;; movq %rdx, 0x10(%rsp) -;; movq %rbx, 0x18(%rsp) -;; movq %rsi, 0x20(%rsp) -;; movq %rdi, 0x28(%rsp) -;; movq %r8, 0x30(%rsp) -;; movq %r9, 0x38(%rsp) -;; movq %r10, 0x40(%rsp) -;; movq %r11, 0x48(%rsp) -;; movdqu %xmm0, 0x50(%rsp) -;; movdqu %xmm1, 0x60(%rsp) -;; movdqu %xmm2, 0x70(%rsp) -;; movdqu %xmm3, 0x80(%rsp) -;; movdqu %xmm4, 0x90(%rsp) -;; movdqu %xmm5, 0xa0(%rsp) -;; movdqu %xmm6, 0xb0(%rsp) -;; movdqu %xmm7, 0xc0(%rsp) -;; movdqu %xmm8, 0xd0(%rsp) -;; movdqu %xmm9, 0xe0(%rsp) -;; movdqu %xmm10, 0xf0(%rsp) -;; movdqu %xmm11, 0x100(%rsp) -;; movdqu %xmm12, 0x110(%rsp) -;; movdqu %xmm13, 0x120(%rsp) -;; movdqu %xmm14, 0x130(%rsp) -;; movdqu %xmm15, 0x140(%rsp) -;; movq 8(%rdi), %r10 -;; movq %rbp, %r11 -;; movq %r11, 0x30(%r10) -;; movq %rbp, %r11 -;; movq 8(%r11), %rax -;; movq %rax, 0x38(%r10) -;; movq 0x10(%rdi), %rax -;; movq 0x170(%rax), %rcx -;; movq %rdi, %rbx -;; callq *%rcx +;; movq %rsi, 0x18(%rsp) +;; movq %rdi, 0x20(%rsp) +;; movq %r8, 0x28(%rsp) +;; movq %r9, 0x30(%rsp) +;; movq %r10, 0x38(%rsp) +;; movq %r11, 0x40(%rsp) +;; movq %r12, 0x48(%rsp) +;; movq %r13, 0x50(%rsp) +;; movdqu %xmm0, 0x60(%rsp) +;; movdqu %xmm1, 0x70(%rsp) +;; movdqu %xmm2, 0x80(%rsp) +;; movdqu %xmm3, 0x90(%rsp) +;; movdqu %xmm4, 0xa0(%rsp) +;; movdqu %xmm5, 0xb0(%rsp) +;; movdqu %xmm6, 0xc0(%rsp) +;; movdqu %xmm7, 0xd0(%rsp) +;; movdqu %xmm8, 0xe0(%rsp) +;; movdqu %xmm9, 0xf0(%rsp) +;; movdqu %xmm10, 0x100(%rsp) +;; movdqu %xmm11, 0x110(%rsp) +;; movdqu %xmm12, 0x120(%rsp) +;; movdqu %xmm13, 0x130(%rsp) +;; movdqu %xmm14, 0x140(%rsp) +;; movdqu %xmm15, 0x150(%rsp) +;; movq %rbp, %r10 +;; movq 8(%rdi), %r9 +;; movq %r10, 0x30(%r9) +;; movq %rbp, %r10 +;; movq 8(%r10), %r11 +;; movq %r11, 0x38(%r9) +;; movq 0x10(%rdi), %r12 +;; movq %rdi, %r13 +;; movq 0x170(%r12), %r11 +;; callq *%r11 ;; testb %al, %al -;; je 0x3af -;; 2e3: movq (%rsp), %rax +;; je 0x3c7 +;; 2f3: movq (%rsp), %rax ;; movq 8(%rsp), %rcx ;; movq 0x10(%rsp), %rdx -;; movq 0x18(%rsp), %rbx -;; movq 0x20(%rsp), %rsi -;; movq 0x28(%rsp), %rdi -;; movq 0x30(%rsp), %r8 -;; movq 0x38(%rsp), %r9 -;; movq 0x40(%rsp), %r10 -;; movq 0x48(%rsp), %r11 -;; movdqu 0x50(%rsp), %xmm0 -;; movdqu 0x60(%rsp), %xmm1 -;; movdqu 0x70(%rsp), %xmm2 -;; movdqu 0x80(%rsp), %xmm3 -;; movdqu 0x90(%rsp), %xmm4 -;; movdqu 0xa0(%rsp), %xmm5 -;; movdqu 0xb0(%rsp), %xmm6 -;; movdqu 0xc0(%rsp), %xmm7 -;; movdqu 0xd0(%rsp), %xmm8 -;; movdqu 0xe0(%rsp), %xmm9 -;; movdqu 0xf0(%rsp), %xmm10 -;; movdqu 0x100(%rsp), %xmm11 -;; movdqu 0x110(%rsp), %xmm12 -;; movdqu 0x120(%rsp), %xmm13 -;; movdqu 0x130(%rsp), %xmm14 -;; movdqu 0x140(%rsp), %xmm15 -;; addq $0x150, %rsp +;; movq 0x18(%rsp), %rsi +;; movq 0x20(%rsp), %rdi +;; movq 0x28(%rsp), %r8 +;; movq 0x30(%rsp), %r9 +;; movq 0x38(%rsp), %r10 +;; movq 0x40(%rsp), %r11 +;; movq 0x48(%rsp), %r12 +;; movq 0x50(%rsp), %r13 +;; movdqu 0x60(%rsp), %xmm0 +;; movdqu 0x70(%rsp), %xmm1 +;; movdqu 0x80(%rsp), %xmm2 +;; movdqu 0x90(%rsp), %xmm3 +;; movdqu 0xa0(%rsp), %xmm4 +;; movdqu 0xb0(%rsp), %xmm5 +;; movdqu 0xc0(%rsp), %xmm6 +;; movdqu 0xd0(%rsp), %xmm7 +;; movdqu 0xe0(%rsp), %xmm8 +;; movdqu 0xf0(%rsp), %xmm9 +;; movdqu 0x100(%rsp), %xmm10 +;; movdqu 0x110(%rsp), %xmm11 +;; movdqu 0x120(%rsp), %xmm12 +;; movdqu 0x130(%rsp), %xmm13 +;; movdqu 0x140(%rsp), %xmm14 +;; movdqu 0x150(%rsp), %xmm15 +;; addq $0x160, %rsp ;; movq %rbp, %rsp ;; popq %rbp ;; retq -;; 3af: movq 0x10(%rbx), %rax -;; 3b3: movq 0x148(%rax), %rax -;; 3ba: movq %rbx, %rdi -;; 3bd: callq *%rax -;; 3bf: ud2 +;; 3c7: movq 0x148(%r12), %rax +;; 3cf: movq %r13, %rdi +;; 3d2: callq *%rax +;; 3d4: ud2 diff --git a/tests/disas/duplicate-function-types.wat b/tests/disas/duplicate-function-types.wat index 4f305bd2e7d8..4b96014bbe86 100644 --- a/tests/disas/duplicate-function-types.wat +++ b/tests/disas/duplicate-function-types.wat @@ -22,7 +22,7 @@ ;; region2 = 1073741824 "PublicTable" ;; region3 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region1 gv3+48 diff --git a/tests/disas/duplicate-loads-dynamic-memory.wat b/tests/disas/duplicate-loads-dynamic-memory.wat index bb12c4f5d953..f7e8e7ff9362 100644 --- a/tests/disas/duplicate-loads-dynamic-memory.wat +++ b/tests/disas/duplicate-loads-dynamic-memory.wat @@ -26,7 +26,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 536870912 "PublicMemory" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -52,7 +52,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 536870912 "PublicMemory" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/duplicate-loads-static-memory.wat b/tests/disas/duplicate-loads-static-memory.wat index 817a5e145580..1a79f735ef6d 100644 --- a/tests/disas/duplicate-loads-static-memory.wat +++ b/tests/disas/duplicate-loads-static-memory.wat @@ -21,7 +21,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 536870912 "PublicMemory" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -43,7 +43,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 536870912 "PublicMemory" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat b/tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat index e823acfe275c..82725f71c04a 100644 --- a/tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat +++ b/tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat @@ -39,7 +39,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 536870912 "PublicMemory" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -74,7 +74,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 536870912 "PublicMemory" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat b/tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat index 7be28a9f0300..0d7ef03f401a 100644 --- a/tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat +++ b/tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat @@ -35,7 +35,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 536870912 "PublicMemory" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -72,7 +72,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 536870912 "PublicMemory" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/epoch-interruption.wat b/tests/disas/epoch-interruption.wat index 1fdbc95c4045..e42883e9c7d5 100644 --- a/tests/disas/epoch-interruption.wat +++ b/tests/disas/epoch-interruption.wat @@ -8,7 +8,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 24 "VMContext+0x18" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx) -> i64 tail ;; fn0 = colocated u805306368:13 sig0 diff --git a/tests/disas/exceptions.wat b/tests/disas/exceptions.wat index e0d23eb92831..8af24433e7a8 100644 --- a/tests/disas/exceptions.wat +++ b/tests/disas/exceptions.wat @@ -33,7 +33,7 @@ ;; movq %rdi, %rbx ;; movq %rcx, %r13 ;; movq %rdx, %r14 -;; callq 0x3e5 +;; callq 0x3eb ;; movq %rax, %r12 ;; movq 0x20(%rbx), %rdx ;; movl (%rdx), %esi @@ -62,7 +62,7 @@ ;; movl $0, 0x14(%rdx) ;; movq %rbx, %rdi ;; movq %rbx, (%rsp) -;; callq 0x412 +;; callq 0x418 ;; ud2 ;; movl $0x4000002, %esi ;; movq 0x28(%rbx), %rax diff --git a/tests/disas/f32-load.wat b/tests/disas/f32-load.wat index 5d74a817cb0f..bfbab24e8b2b 100644 --- a/tests/disas/f32-load.wat +++ b/tests/disas/f32-load.wat @@ -10,7 +10,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/f32-store.wat b/tests/disas/f32-store.wat index 4fb9641a605d..b4f390230137 100644 --- a/tests/disas/f32-store.wat +++ b/tests/disas/f32-store.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/f64-load.wat b/tests/disas/f64-load.wat index b437fcd75e0a..517a63e1044e 100644 --- a/tests/disas/f64-load.wat +++ b/tests/disas/f64-load.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/f64-store.wat b/tests/disas/f64-store.wat index 616dc74a884c..8f1516148e05 100644 --- a/tests/disas/f64-store.wat +++ b/tests/disas/f64-store.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/fac-multi-value.wat b/tests/disas/fac-multi-value.wat index 5d38507122a7..186710284651 100644 --- a/tests/disas/fac-multi-value.wat +++ b/tests/disas/fac-multi-value.wat @@ -23,7 +23,7 @@ ;; function u0:0(i64 vmctx, i64, i64) -> i64, i64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -37,7 +37,7 @@ ;; function u0:1(i64 vmctx, i64, i64, i64) -> i64, i64, i64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -51,7 +51,7 @@ ;; function u0:2(i64 vmctx, i64, i64) -> i64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i64, i64, i64) -> i64, i64, i64 tail ;; sig1 = (i64 vmctx, i64, i64) -> i64, i64 tail diff --git a/tests/disas/fibonacci.wat b/tests/disas/fibonacci.wat index e68275a0eabc..87c9551ef0b4 100644 --- a/tests/disas/fibonacci.wat +++ b/tests/disas/fibonacci.wat @@ -27,7 +27,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/fixed-size-memory.wat b/tests/disas/fixed-size-memory.wat index 306ebc1ea59e..b7af3ec1f8e2 100644 --- a/tests/disas/fixed-size-memory.wat +++ b/tests/disas/fixed-size-memory.wat @@ -24,7 +24,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/foo.wat b/tests/disas/foo.wat index c9623bd61665..aafd79d7fb65 100644 --- a/tests/disas/foo.wat +++ b/tests/disas/foo.wat @@ -21,7 +21,7 @@ ;; region3 = 1073741824 "PublicTable" ;; region4 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/gc/array-copy-with-fuel.wat b/tests/disas/gc/array-copy-with-fuel.wat index 8dfe01edcabe..cdf3d088ecd2 100644 --- a/tests/disas/gc/array-copy-with-fuel.wat +++ b/tests/disas/gc/array-copy-with-fuel.wat @@ -15,7 +15,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/array-fill-i8.wat b/tests/disas/gc/array-fill-i8.wat index 4fcba6ff9c34..680e191e6989 100644 --- a/tests/disas/gc/array-fill-i8.wat +++ b/tests/disas/gc/array-fill-i8.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/array-init-data.wat b/tests/disas/gc/array-init-data.wat index cb3e0fa17bc3..881bdb7dd0e9 100644 --- a/tests/disas/gc/array-init-data.wat +++ b/tests/disas/gc/array-init-data.wat @@ -19,7 +19,7 @@ ;; region2 = 56 "VMContext+0x38" ;; region3 = 48 "VMContext+0x30" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/array-new-data.wat b/tests/disas/gc/array-new-data.wat index c7e570db4db4..afa5487d7ea2 100644 --- a/tests/disas/gc/array-new-data.wat +++ b/tests/disas/gc/array-new-data.wat @@ -84,7 +84,7 @@ ;; region4 = 40 "VMContext+0x28" ;; region5 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -130,7 +130,7 @@ ;; v126 = iconst.i32 -16 ;; v127 = band v123, v126 ; v126 = -16 ;; v129 = iadd.i32 v25, v127 -;; @0025 store notrap aligned region3 v129, v24 +;; @0025 store notrap aligned v129, v24 ;; v143 = iconst.i32 -1476395002 ;; v144 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v145 = load.i64 notrap aligned readonly can_move v144+32 diff --git a/tests/disas/gc/array-new-default-anyref.wat b/tests/disas/gc/array-new-default-anyref.wat index 734c11f9b00f..6287b320f91d 100644 --- a/tests/disas/gc/array-new-default-anyref.wat +++ b/tests/disas/gc/array-new-default-anyref.wat @@ -15,7 +15,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -56,7 +56,7 @@ ;; v109 = iconst.i32 -16 ;; v110 = band v106, v109 ; v109 = -16 ;; v112 = iadd.i32 v13, v110 -;; @001f store notrap aligned region1 v112, v12 +;; @001f store notrap aligned v112, v12 ;; v128 = iconst.i32 -1476394994 ;; v129 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v130 = load.i64 notrap aligned readonly can_move v129+32 diff --git a/tests/disas/gc/array-new-default-exnref.wat b/tests/disas/gc/array-new-default-exnref.wat index 36370ff246c4..6f5a8d34076a 100644 --- a/tests/disas/gc/array-new-default-exnref.wat +++ b/tests/disas/gc/array-new-default-exnref.wat @@ -15,7 +15,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -56,7 +56,7 @@ ;; v109 = iconst.i32 -16 ;; v110 = band v106, v109 ; v109 = -16 ;; v112 = iadd.i32 v13, v110 -;; @001f store notrap aligned region1 v112, v12 +;; @001f store notrap aligned v112, v12 ;; v128 = iconst.i32 -1476394994 ;; v129 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v130 = load.i64 notrap aligned readonly can_move v129+32 diff --git a/tests/disas/gc/array-new-default-externref.wat b/tests/disas/gc/array-new-default-externref.wat index 2f701d49ff8f..dea3b6fe373b 100644 --- a/tests/disas/gc/array-new-default-externref.wat +++ b/tests/disas/gc/array-new-default-externref.wat @@ -15,7 +15,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -56,7 +56,7 @@ ;; v109 = iconst.i32 -16 ;; v110 = band v106, v109 ; v109 = -16 ;; v112 = iadd.i32 v13, v110 -;; @001f store notrap aligned region1 v112, v12 +;; @001f store notrap aligned v112, v12 ;; v128 = iconst.i32 -1476394994 ;; v129 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v130 = load.i64 notrap aligned readonly can_move v129+32 diff --git a/tests/disas/gc/array-new-default-f32.wat b/tests/disas/gc/array-new-default-f32.wat index 966f4fccdf0a..6e31843273a5 100644 --- a/tests/disas/gc/array-new-default-f32.wat +++ b/tests/disas/gc/array-new-default-f32.wat @@ -16,7 +16,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -59,7 +59,7 @@ ;; v112 = iconst.i32 -16 ;; v113 = band v109, v112 ; v112 = -16 ;; v115 = iadd.i32 v13, v113 -;; @001f store notrap aligned region1 v115, v12 +;; @001f store notrap aligned v115, v12 ;; v131 = iconst.i32 -1476395002 ;; v132 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v133 = load.i64 notrap aligned readonly can_move v132+32 diff --git a/tests/disas/gc/array-new-default-f64.wat b/tests/disas/gc/array-new-default-f64.wat index 42be9b5c0b61..07d6ce96ef08 100644 --- a/tests/disas/gc/array-new-default-f64.wat +++ b/tests/disas/gc/array-new-default-f64.wat @@ -16,7 +16,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -59,7 +59,7 @@ ;; v112 = iconst.i32 -16 ;; v113 = band v109, v112 ; v112 = -16 ;; v115 = iadd.i32 v13, v113 -;; @001f store notrap aligned region1 v115, v12 +;; @001f store notrap aligned v115, v12 ;; v131 = iconst.i32 -1476395002 ;; v132 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v133 = load.i64 notrap aligned readonly can_move v132+32 diff --git a/tests/disas/gc/array-new-default-funcref.wat b/tests/disas/gc/array-new-default-funcref.wat index e11216989a40..a5f13694ad06 100644 --- a/tests/disas/gc/array-new-default-funcref.wat +++ b/tests/disas/gc/array-new-default-funcref.wat @@ -16,7 +16,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -59,7 +59,7 @@ ;; v120 = iconst.i32 -16 ;; v121 = band v117, v120 ; v120 = -16 ;; v123 = iadd.i32 v13, v121 -;; @001f store notrap aligned region1 v123, v12 +;; @001f store notrap aligned v123, v12 ;; v138 = iconst.i32 -1476395002 ;; v139 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v140 = load.i64 notrap aligned readonly can_move v139+32 diff --git a/tests/disas/gc/array-new-default-i16.wat b/tests/disas/gc/array-new-default-i16.wat index d621d004d0fa..3f96fb0e0c4f 100644 --- a/tests/disas/gc/array-new-default-i16.wat +++ b/tests/disas/gc/array-new-default-i16.wat @@ -16,7 +16,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -58,7 +58,7 @@ ;; v117 = iconst.i32 -16 ;; v118 = band v114, v117 ; v117 = -16 ;; v120 = iadd.i32 v13, v118 -;; @001f store notrap aligned region1 v120, v12 +;; @001f store notrap aligned v120, v12 ;; v141 = iconst.i32 -1476395002 ;; v142 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v143 = load.i64 notrap aligned readonly can_move v142+32 diff --git a/tests/disas/gc/array-new-default-i32.wat b/tests/disas/gc/array-new-default-i32.wat index acfcbcad5ced..d03ed578e55a 100644 --- a/tests/disas/gc/array-new-default-i32.wat +++ b/tests/disas/gc/array-new-default-i32.wat @@ -16,7 +16,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -59,7 +59,7 @@ ;; v112 = iconst.i32 -16 ;; v113 = band v109, v112 ; v112 = -16 ;; v115 = iadd.i32 v13, v113 -;; @001f store notrap aligned region1 v115, v12 +;; @001f store notrap aligned v115, v12 ;; v131 = iconst.i32 -1476395002 ;; v132 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v133 = load.i64 notrap aligned readonly can_move v132+32 diff --git a/tests/disas/gc/array-new-default-i64.wat b/tests/disas/gc/array-new-default-i64.wat index 3a77509ee9dd..9f7a3df07c82 100644 --- a/tests/disas/gc/array-new-default-i64.wat +++ b/tests/disas/gc/array-new-default-i64.wat @@ -16,7 +16,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -59,7 +59,7 @@ ;; v112 = iconst.i32 -16 ;; v113 = band v109, v112 ; v112 = -16 ;; v115 = iadd.i32 v13, v113 -;; @001f store notrap aligned region1 v115, v12 +;; @001f store notrap aligned v115, v12 ;; v130 = iconst.i32 -1476395002 ;; v131 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v132 = load.i64 notrap aligned readonly can_move v131+32 diff --git a/tests/disas/gc/array-new-default-i8.wat b/tests/disas/gc/array-new-default-i8.wat index 870f4b36639f..8bdaeec884a1 100644 --- a/tests/disas/gc/array-new-default-i8.wat +++ b/tests/disas/gc/array-new-default-i8.wat @@ -16,7 +16,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -55,7 +55,7 @@ ;; v102 = iconst.i32 -16 ;; v103 = band v99, v102 ; v102 = -16 ;; v105 = iadd.i32 v13, v103 -;; @001f store notrap aligned region1 v105, v12 +;; @001f store notrap aligned v105, v12 ;; v119 = iconst.i32 -1476395002 ;; v120 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v121 = load.i64 notrap aligned readonly can_move v120+32 diff --git a/tests/disas/gc/call-indirect-final-type.wat b/tests/disas/gc/call-indirect-final-type.wat index 0406261611bf..ee89c876c8ab 100644 --- a/tests/disas/gc/call-indirect-final-type.wat +++ b/tests/disas/gc/call-indirect-final-type.wat @@ -20,7 +20,7 @@ ;; region1 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; region2 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+48 @@ -71,7 +71,7 @@ ;; region1 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; region2 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+48 diff --git a/tests/disas/gc/copying/array-fill.wat b/tests/disas/gc/copying/array-fill.wat index 28f108b43a2f..c49fe09ff2dd 100644 --- a/tests/disas/gc/copying/array-fill.wat +++ b/tests/disas/gc/copying/array-fill.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/array-get-s.wat b/tests/disas/gc/copying/array-get-s.wat index aabbaa78c692..f2d6854cd514 100644 --- a/tests/disas/gc/copying/array-get-s.wat +++ b/tests/disas/gc/copying/array-get-s.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/array-get-u.wat b/tests/disas/gc/copying/array-get-u.wat index 3428182d3638..bc7682a5dc10 100644 --- a/tests/disas/gc/copying/array-get-u.wat +++ b/tests/disas/gc/copying/array-get-u.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/array-get.wat b/tests/disas/gc/copying/array-get.wat index 774dde5b8245..8ffcf35d5368 100644 --- a/tests/disas/gc/copying/array-get.wat +++ b/tests/disas/gc/copying/array-get.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/array-len.wat b/tests/disas/gc/copying/array-len.wat index 15aebdc65bc0..61cfb5769f79 100644 --- a/tests/disas/gc/copying/array-len.wat +++ b/tests/disas/gc/copying/array-len.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/array-new-fixed-of-gc-refs.wat b/tests/disas/gc/copying/array-new-fixed-of-gc-refs.wat index 5fe728de1c07..917f6e9ab12d 100644 --- a/tests/disas/gc/copying/array-new-fixed-of-gc-refs.wat +++ b/tests/disas/gc/copying/array-new-fixed-of-gc-refs.wat @@ -17,7 +17,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -47,7 +47,7 @@ ;; block2: ;; v266 = iconst.i32 32 ;; v172 = iadd.i32 v16, v266 ; v266 = 32 -;; @0025 store notrap aligned region1 v172, v15 +;; @0025 store notrap aligned v172, v15 ;; v267 = iconst.i32 -1476394994 ;; v268 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v269 = load.i64 notrap aligned readonly can_move v268+32 diff --git a/tests/disas/gc/copying/array-new-fixed.wat b/tests/disas/gc/copying/array-new-fixed.wat index 653dfe3549ff..b5f3cb130a36 100644 --- a/tests/disas/gc/copying/array-new-fixed.wat +++ b/tests/disas/gc/copying/array-new-fixed.wat @@ -14,7 +14,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -38,7 +38,7 @@ ;; block2: ;; v254 = iconst.i32 48 ;; v162 = iadd.i32 v16, v254 ; v254 = 48 -;; @0025 store notrap aligned region1 v162, v15 +;; @0025 store notrap aligned v162, v15 ;; v255 = iconst.i32 -1476395002 ;; v256 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v257 = load.i64 notrap aligned readonly can_move v256+32 diff --git a/tests/disas/gc/copying/array-new.wat b/tests/disas/gc/copying/array-new.wat index b42b5d794cc8..6599307330af 100644 --- a/tests/disas/gc/copying/array-new.wat +++ b/tests/disas/gc/copying/array-new.wat @@ -14,7 +14,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -55,7 +55,7 @@ ;; v109 = iconst.i32 -16 ;; v110 = band v106, v109 ; v109 = -16 ;; v112 = iadd.i32 v14, v110 -;; @0022 store notrap aligned region1 v112, v13 +;; @0022 store notrap aligned v112, v13 ;; v128 = iconst.i32 -1476395002 ;; v129 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v130 = load.i64 notrap aligned readonly can_move v129+32 diff --git a/tests/disas/gc/copying/array-set.wat b/tests/disas/gc/copying/array-set.wat index d2383480c36b..6802be5f1ec7 100644 --- a/tests/disas/gc/copying/array-set.wat +++ b/tests/disas/gc/copying/array-set.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/br-on-cast-fail.wat b/tests/disas/gc/copying/br-on-cast-fail.wat index 174b50128814..e1d94aaebb15 100644 --- a/tests/disas/gc/copying/br-on-cast-fail.wat +++ b/tests/disas/gc/copying/br-on-cast-fail.wat @@ -24,7 +24,7 @@ ;; region5 = 104 "VMContext+0x68" ;; region6 = 88 "VMContext+0x58" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -41,12 +41,12 @@ ;; block3: ;; @002e v8 = iconst.i32 1 ;; @002e v9 = band.i32 v2, v8 ; v8 = 1 -;; v30 = iconst.i32 0 -;; @002e brif v9, block5(v30), block4 ; v30 = 0 +;; v28 = iconst.i32 0 +;; @002e brif v9, block5(v28), block4 ; v28 = 0 ;; ;; block4: -;; @002e v28 = load.i64 notrap aligned readonly can_move region0 v0+8 -;; @002e v14 = load.i64 notrap aligned readonly can_move v28+32 +;; @002e v26 = load.i64 notrap aligned readonly can_move region0 v0+8 +;; @002e v14 = load.i64 notrap aligned readonly can_move v26+32 ;; @002e v13 = uextend.i64 v2 ;; @002e v15 = iadd v14, v13 ;; @002e v16 = iconst.i64 4 @@ -62,14 +62,14 @@ ;; @002e brif v21, block6, block2 ;; ;; block6: -;; @0034 v24 = load.i64 notrap aligned readonly can_move region4 v0+56 -;; @0034 v23 = load.i64 notrap aligned readonly can_move region3 v0+72 -;; @0034 call_indirect sig0, v24(v23, v0) +;; @0034 v23 = load.i64 notrap aligned readonly can_move region4 v0+56 +;; @0034 v22 = load.i64 notrap aligned readonly can_move region3 v0+72 +;; @0034 call_indirect sig0, v23(v22, v0) ;; @0036 return ;; ;; block2: -;; @0038 v27 = load.i64 notrap aligned readonly can_move region6 v0+88 -;; @0038 v26 = load.i64 notrap aligned readonly can_move region5 v0+104 -;; @0038 call_indirect sig0, v27(v26, v0) +;; @0038 v25 = load.i64 notrap aligned readonly can_move region6 v0+88 +;; @0038 v24 = load.i64 notrap aligned readonly can_move region5 v0+104 +;; @0038 call_indirect sig0, v25(v24, v0) ;; @003a return ;; } diff --git a/tests/disas/gc/copying/br-on-cast.wat b/tests/disas/gc/copying/br-on-cast.wat index 8b279d1722a1..5adac386e2dc 100644 --- a/tests/disas/gc/copying/br-on-cast.wat +++ b/tests/disas/gc/copying/br-on-cast.wat @@ -24,7 +24,7 @@ ;; region5 = 104 "VMContext+0x68" ;; region6 = 88 "VMContext+0x58" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -41,12 +41,12 @@ ;; block3: ;; @002f v8 = iconst.i32 1 ;; @002f v9 = band.i32 v2, v8 ; v8 = 1 -;; v30 = iconst.i32 0 -;; @002f brif v9, block5(v30), block4 ; v30 = 0 +;; v28 = iconst.i32 0 +;; @002f brif v9, block5(v28), block4 ; v28 = 0 ;; ;; block4: -;; @002f v28 = load.i64 notrap aligned readonly can_move region0 v0+8 -;; @002f v14 = load.i64 notrap aligned readonly can_move v28+32 +;; @002f v26 = load.i64 notrap aligned readonly can_move region0 v0+8 +;; @002f v14 = load.i64 notrap aligned readonly can_move v26+32 ;; @002f v13 = uextend.i64 v2 ;; @002f v15 = iadd v14, v13 ;; @002f v16 = iconst.i64 4 @@ -62,14 +62,14 @@ ;; @002f brif v21, block2, block6 ;; ;; block6: -;; @0035 v24 = load.i64 notrap aligned readonly can_move region4 v0+56 -;; @0035 v23 = load.i64 notrap aligned readonly can_move region3 v0+72 -;; @0035 call_indirect sig0, v24(v23, v0) +;; @0035 v23 = load.i64 notrap aligned readonly can_move region4 v0+56 +;; @0035 v22 = load.i64 notrap aligned readonly can_move region3 v0+72 +;; @0035 call_indirect sig0, v23(v22, v0) ;; @0037 return ;; ;; block2: -;; @0039 v27 = load.i64 notrap aligned readonly can_move region6 v0+88 -;; @0039 v26 = load.i64 notrap aligned readonly can_move region5 v0+104 -;; @0039 call_indirect sig0, v27(v26, v0) +;; @0039 v25 = load.i64 notrap aligned readonly can_move region6 v0+88 +;; @0039 v24 = load.i64 notrap aligned readonly can_move region5 v0+104 +;; @0039 call_indirect sig0, v25(v24, v0) ;; @003b return ;; } diff --git a/tests/disas/gc/copying/call-indirect-and-subtyping.wat b/tests/disas/gc/copying/call-indirect-and-subtyping.wat index 9bb7b97a0e3c..99586b7fa170 100644 --- a/tests/disas/gc/copying/call-indirect-and-subtyping.wat +++ b/tests/disas/gc/copying/call-indirect-and-subtyping.wat @@ -20,7 +20,7 @@ ;; region1 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; region2 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+112 diff --git a/tests/disas/gc/copying/externref-globals.wat b/tests/disas/gc/copying/externref-globals.wat index 988cf362de25..333fff8b6845 100644 --- a/tests/disas/gc/copying/externref-globals.wat +++ b/tests/disas/gc/copying/externref-globals.wat @@ -13,7 +13,7 @@ ;; function u0:0(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; stack_limit = gv2 @@ -31,7 +31,7 @@ ;; function u0:1(i64 vmctx, i64, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; stack_limit = gv2 diff --git a/tests/disas/gc/copying/funcref-in-gc-heap-get.wat b/tests/disas/gc/copying/funcref-in-gc-heap-get.wat index d45c944fb344..20cb0f4e9496 100644 --- a/tests/disas/gc/copying/funcref-in-gc-heap-get.wat +++ b/tests/disas/gc/copying/funcref-in-gc-heap-get.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/funcref-in-gc-heap-new.wat b/tests/disas/gc/copying/funcref-in-gc-heap-new.wat index a76e73932eb2..b0c2e7e1fdef 100644 --- a/tests/disas/gc/copying/funcref-in-gc-heap-new.wat +++ b/tests/disas/gc/copying/funcref-in-gc-heap-new.wat @@ -15,7 +15,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail ;; sig1 = (i64 vmctx, i64) -> i64 tail @@ -37,7 +37,7 @@ ;; block2: ;; v59 = iconst.i32 32 ;; v57 = iadd.i32 v6, v59 ; v59 = 32 -;; @0020 store notrap aligned region1 v57, v5 +;; @0020 store notrap aligned v57, v5 ;; v60 = iconst.i32 -1342177278 ;; v61 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v62 = load.i64 notrap aligned readonly can_move v61+32 diff --git a/tests/disas/gc/copying/funcref-in-gc-heap-set.wat b/tests/disas/gc/copying/funcref-in-gc-heap-set.wat index c8f83fcf54a0..fc7a698c8f53 100644 --- a/tests/disas/gc/copying/funcref-in-gc-heap-set.wat +++ b/tests/disas/gc/copying/funcref-in-gc-heap-set.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/i31ref-globals.wat b/tests/disas/gc/copying/i31ref-globals.wat index a3472a9fefd7..793c849b5af1 100644 --- a/tests/disas/gc/copying/i31ref-globals.wat +++ b/tests/disas/gc/copying/i31ref-globals.wat @@ -13,7 +13,7 @@ ;; function u0:0(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; stack_limit = gv2 @@ -31,7 +31,7 @@ ;; function u0:1(i64 vmctx, i64, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; stack_limit = gv2 diff --git a/tests/disas/gc/copying/multiple-array-get.wat b/tests/disas/gc/copying/multiple-array-get.wat index 14df59b91a1a..43eba54e7a25 100644 --- a/tests/disas/gc/copying/multiple-array-get.wat +++ b/tests/disas/gc/copying/multiple-array-get.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/multiple-struct-get.wat b/tests/disas/gc/copying/multiple-struct-get.wat index d43c5ed83c01..8dcebc26c3ee 100644 --- a/tests/disas/gc/copying/multiple-struct-get.wat +++ b/tests/disas/gc/copying/multiple-struct-get.wat @@ -14,7 +14,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/ref-cast.wat b/tests/disas/gc/copying/ref-cast.wat index aa33af730bf5..642967593fdb 100644 --- a/tests/disas/gc/copying/ref-cast.wat +++ b/tests/disas/gc/copying/ref-cast.wat @@ -12,7 +12,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/ref-is-null.wat b/tests/disas/gc/copying/ref-is-null.wat index 844a988770cf..d114df3e8067 100644 --- a/tests/disas/gc/copying/ref-is-null.wat +++ b/tests/disas/gc/copying/ref-is-null.wat @@ -12,7 +12,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -29,7 +29,7 @@ ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/gc/copying/ref-test-any.wat b/tests/disas/gc/copying/ref-test-any.wat index e731f4a50a5f..08d6836cd31a 100644 --- a/tests/disas/gc/copying/ref-test-any.wat +++ b/tests/disas/gc/copying/ref-test-any.wat @@ -12,7 +12,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -29,7 +29,7 @@ ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/gc/copying/ref-test-array.wat b/tests/disas/gc/copying/ref-test-array.wat index d82bdf296211..6da57f42ddbf 100644 --- a/tests/disas/gc/copying/ref-test-array.wat +++ b/tests/disas/gc/copying/ref-test-array.wat @@ -10,7 +10,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/ref-test-concrete-func-type.wat b/tests/disas/gc/copying/ref-test-concrete-func-type.wat index 51c2893b4ecf..f3ce9c91ab95 100644 --- a/tests/disas/gc/copying/ref-test-concrete-func-type.wat +++ b/tests/disas/gc/copying/ref-test-concrete-func-type.wat @@ -12,7 +12,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/gc/copying/ref-test-concrete-type.wat b/tests/disas/gc/copying/ref-test-concrete-type.wat index e93e7b2252c4..3dddcec681f0 100644 --- a/tests/disas/gc/copying/ref-test-concrete-type.wat +++ b/tests/disas/gc/copying/ref-test-concrete-type.wat @@ -12,7 +12,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/ref-test-eq.wat b/tests/disas/gc/copying/ref-test-eq.wat index 3da581adee79..e1ef88fc760c 100644 --- a/tests/disas/gc/copying/ref-test-eq.wat +++ b/tests/disas/gc/copying/ref-test-eq.wat @@ -10,7 +10,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/ref-test-i31.wat b/tests/disas/gc/copying/ref-test-i31.wat index 06576794c82f..67f1150a1545 100644 --- a/tests/disas/gc/copying/ref-test-i31.wat +++ b/tests/disas/gc/copying/ref-test-i31.wat @@ -9,7 +9,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/gc/copying/ref-test-none.wat b/tests/disas/gc/copying/ref-test-none.wat index a1448bb257c2..d292f3a4095d 100644 --- a/tests/disas/gc/copying/ref-test-none.wat +++ b/tests/disas/gc/copying/ref-test-none.wat @@ -12,7 +12,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -27,7 +27,7 @@ ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/gc/copying/ref-test-struct.wat b/tests/disas/gc/copying/ref-test-struct.wat index d8113f999d6d..eb5b873dbb95 100644 --- a/tests/disas/gc/copying/ref-test-struct.wat +++ b/tests/disas/gc/copying/ref-test-struct.wat @@ -10,7 +10,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/struct-get.wat b/tests/disas/gc/copying/struct-get.wat index dca87de4ef15..c1873f14eec4 100644 --- a/tests/disas/gc/copying/struct-get.wat +++ b/tests/disas/gc/copying/struct-get.wat @@ -26,7 +26,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -53,7 +53,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -81,7 +81,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -109,7 +109,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/struct-new-default.wat b/tests/disas/gc/copying/struct-new-default.wat index 16af25c34f78..918b09538eac 100644 --- a/tests/disas/gc/copying/struct-new-default.wat +++ b/tests/disas/gc/copying/struct-new-default.wat @@ -16,7 +16,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail ;; fn0 = colocated u805306368:24 sig0 @@ -36,7 +36,7 @@ ;; block2: ;; v60 = iconst.i32 32 ;; v58 = iadd.i32 v8, v60 ; v60 = 32 -;; @0021 store notrap aligned region1 v58, v7 +;; @0021 store notrap aligned v58, v7 ;; v61 = iconst.i32 -1342177246 ;; v62 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v63 = load.i64 notrap aligned readonly can_move v62+32 diff --git a/tests/disas/gc/copying/struct-new.wat b/tests/disas/gc/copying/struct-new.wat index 0d516db1c89a..4579ad46a12b 100644 --- a/tests/disas/gc/copying/struct-new.wat +++ b/tests/disas/gc/copying/struct-new.wat @@ -17,7 +17,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail ;; fn0 = colocated u805306368:24 sig0 @@ -39,7 +39,7 @@ ;; block2: ;; v63 = iconst.i32 32 ;; v61 = iadd.i32 v8, v63 ; v63 = 32 -;; @002a store notrap aligned region1 v61, v7 +;; @002a store notrap aligned v61, v7 ;; v64 = iconst.i32 -1342177246 ;; v65 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v66 = load.i64 notrap aligned readonly can_move v65+32 diff --git a/tests/disas/gc/copying/struct-set.wat b/tests/disas/gc/copying/struct-set.wat index e25eaa5ec348..f6fb86b15e71 100644 --- a/tests/disas/gc/copying/struct-set.wat +++ b/tests/disas/gc/copying/struct-set.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -76,7 +76,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/copying/v128-fields.wat b/tests/disas/gc/copying/v128-fields.wat index 2419c82a6127..90a7f5eb69b3 100644 --- a/tests/disas/gc/copying/v128-fields.wat +++ b/tests/disas/gc/copying/v128-fields.wat @@ -14,7 +14,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/array-fill.wat b/tests/disas/gc/drc/array-fill.wat index 557cc3a6b930..439c81f44dc0 100644 --- a/tests/disas/gc/drc/array-fill.wat +++ b/tests/disas/gc/drc/array-fill.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/array-get-s.wat b/tests/disas/gc/drc/array-get-s.wat index 0a7bbe14ab2c..6f24b7fa070b 100644 --- a/tests/disas/gc/drc/array-get-s.wat +++ b/tests/disas/gc/drc/array-get-s.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/array-get-u.wat b/tests/disas/gc/drc/array-get-u.wat index 5e4598b07d18..a0ecb5bca3f7 100644 --- a/tests/disas/gc/drc/array-get-u.wat +++ b/tests/disas/gc/drc/array-get-u.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/array-get.wat b/tests/disas/gc/drc/array-get.wat index a7647c0f6d25..64f4407537eb 100644 --- a/tests/disas/gc/drc/array-get.wat +++ b/tests/disas/gc/drc/array-get.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/array-len.wat b/tests/disas/gc/drc/array-len.wat index df4e5db78094..8f74190c6a0e 100644 --- a/tests/disas/gc/drc/array-len.wat +++ b/tests/disas/gc/drc/array-len.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/array-new-fixed-of-gc-refs.wat b/tests/disas/gc/drc/array-new-fixed-of-gc-refs.wat index dedd134c5262..88250179f6fc 100644 --- a/tests/disas/gc/drc/array-new-fixed-of-gc-refs.wat +++ b/tests/disas/gc/drc/array-new-fixed-of-gc-refs.wat @@ -17,7 +17,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/array-new-fixed.wat b/tests/disas/gc/drc/array-new-fixed.wat index 5240375cf28c..4c549b6380fb 100644 --- a/tests/disas/gc/drc/array-new-fixed.wat +++ b/tests/disas/gc/drc/array-new-fixed.wat @@ -14,7 +14,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/array-new.wat b/tests/disas/gc/drc/array-new.wat index c4db33fcf5e1..fc8844bf304d 100644 --- a/tests/disas/gc/drc/array-new.wat +++ b/tests/disas/gc/drc/array-new.wat @@ -14,7 +14,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/array-set.wat b/tests/disas/gc/drc/array-set.wat index ab329709537a..02adf4fb21e6 100644 --- a/tests/disas/gc/drc/array-set.wat +++ b/tests/disas/gc/drc/array-set.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/br-on-cast-fail.wat b/tests/disas/gc/drc/br-on-cast-fail.wat index 2526a4d22630..5415ba099b06 100644 --- a/tests/disas/gc/drc/br-on-cast-fail.wat +++ b/tests/disas/gc/drc/br-on-cast-fail.wat @@ -25,7 +25,7 @@ ;; region5 = 104 "VMContext+0x68" ;; region6 = 88 "VMContext+0x58" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -42,12 +42,12 @@ ;; block3: ;; @002e v8 = iconst.i32 1 ;; @002e v9 = band.i32 v2, v8 ; v8 = 1 -;; v30 = iconst.i32 0 -;; @002e brif v9, block5(v30), block4 ; v30 = 0 +;; v28 = iconst.i32 0 +;; @002e brif v9, block5(v28), block4 ; v28 = 0 ;; ;; block4: -;; @002e v28 = load.i64 notrap aligned readonly can_move region0 v0+8 -;; @002e v14 = load.i64 notrap aligned readonly can_move v28+32 +;; @002e v26 = load.i64 notrap aligned readonly can_move region0 v0+8 +;; @002e v14 = load.i64 notrap aligned readonly can_move v26+32 ;; @002e v13 = uextend.i64 v2 ;; @002e v15 = iadd v14, v13 ;; @002e v16 = iconst.i64 4 @@ -63,14 +63,14 @@ ;; @002e brif v21, block6, block2 ;; ;; block6: -;; @0034 v24 = load.i64 notrap aligned readonly can_move region4 v0+56 -;; @0034 v23 = load.i64 notrap aligned readonly can_move region3 v0+72 -;; @0034 call_indirect sig0, v24(v23, v0) +;; @0034 v23 = load.i64 notrap aligned readonly can_move region4 v0+56 +;; @0034 v22 = load.i64 notrap aligned readonly can_move region3 v0+72 +;; @0034 call_indirect sig0, v23(v22, v0) ;; @0036 return ;; ;; block2: -;; @0038 v27 = load.i64 notrap aligned readonly can_move region6 v0+88 -;; @0038 v26 = load.i64 notrap aligned readonly can_move region5 v0+104 -;; @0038 call_indirect sig0, v27(v26, v0) +;; @0038 v25 = load.i64 notrap aligned readonly can_move region6 v0+88 +;; @0038 v24 = load.i64 notrap aligned readonly can_move region5 v0+104 +;; @0038 call_indirect sig0, v25(v24, v0) ;; @003a return ;; } diff --git a/tests/disas/gc/drc/br-on-cast.wat b/tests/disas/gc/drc/br-on-cast.wat index edb972b40ec6..17b8c650529f 100644 --- a/tests/disas/gc/drc/br-on-cast.wat +++ b/tests/disas/gc/drc/br-on-cast.wat @@ -25,7 +25,7 @@ ;; region5 = 104 "VMContext+0x68" ;; region6 = 88 "VMContext+0x58" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -42,12 +42,12 @@ ;; block3: ;; @002f v8 = iconst.i32 1 ;; @002f v9 = band.i32 v2, v8 ; v8 = 1 -;; v30 = iconst.i32 0 -;; @002f brif v9, block5(v30), block4 ; v30 = 0 +;; v28 = iconst.i32 0 +;; @002f brif v9, block5(v28), block4 ; v28 = 0 ;; ;; block4: -;; @002f v28 = load.i64 notrap aligned readonly can_move region0 v0+8 -;; @002f v14 = load.i64 notrap aligned readonly can_move v28+32 +;; @002f v26 = load.i64 notrap aligned readonly can_move region0 v0+8 +;; @002f v14 = load.i64 notrap aligned readonly can_move v26+32 ;; @002f v13 = uextend.i64 v2 ;; @002f v15 = iadd v14, v13 ;; @002f v16 = iconst.i64 4 @@ -63,14 +63,14 @@ ;; @002f brif v21, block2, block6 ;; ;; block6: -;; @0035 v24 = load.i64 notrap aligned readonly can_move region4 v0+56 -;; @0035 v23 = load.i64 notrap aligned readonly can_move region3 v0+72 -;; @0035 call_indirect sig0, v24(v23, v0) +;; @0035 v23 = load.i64 notrap aligned readonly can_move region4 v0+56 +;; @0035 v22 = load.i64 notrap aligned readonly can_move region3 v0+72 +;; @0035 call_indirect sig0, v23(v22, v0) ;; @0037 return ;; ;; block2: -;; @0039 v27 = load.i64 notrap aligned readonly can_move region6 v0+88 -;; @0039 v26 = load.i64 notrap aligned readonly can_move region5 v0+104 -;; @0039 call_indirect sig0, v27(v26, v0) +;; @0039 v25 = load.i64 notrap aligned readonly can_move region6 v0+88 +;; @0039 v24 = load.i64 notrap aligned readonly can_move region5 v0+104 +;; @0039 call_indirect sig0, v25(v24, v0) ;; @003b return ;; } diff --git a/tests/disas/gc/drc/call-indirect-and-subtyping.wat b/tests/disas/gc/drc/call-indirect-and-subtyping.wat index 83616d1c8ef3..3d97ae43b1d2 100644 --- a/tests/disas/gc/drc/call-indirect-and-subtyping.wat +++ b/tests/disas/gc/drc/call-indirect-and-subtyping.wat @@ -21,7 +21,7 @@ ;; region1 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; region2 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+112 diff --git a/tests/disas/gc/drc/externref-globals.wat b/tests/disas/gc/drc/externref-globals.wat index bacf483e8b2d..37d3c435bcd4 100644 --- a/tests/disas/gc/drc/externref-globals.wat +++ b/tests/disas/gc/drc/externref-globals.wat @@ -18,7 +18,7 @@ ;; region1 = 2147483648 "GcHeap" ;; region2 = 32 "VMContext+0x20" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -32,8 +32,8 @@ ;; @0034 v4 = iconst.i64 48 ;; @0034 v5 = iadd v0, v4 ; v4 = 48 ;; @0034 v6 = load.i32 notrap aligned v5 -;; v81 = stack_addr.i64 ss0 -;; store notrap v6, v81 +;; v76 = stack_addr.i64 ss0 +;; store notrap v6, v76 ;; @0034 v7 = iconst.i32 1 ;; @0034 v8 = band v6, v7 ; v7 = 1 ;; @0034 v9 = iconst.i32 0 @@ -43,8 +43,8 @@ ;; @0034 brif v12, block4, block2 ;; ;; block2: -;; @0034 v90 = load.i64 notrap aligned readonly can_move region0 v0+8 -;; @0034 v14 = load.i64 notrap aligned readonly can_move v90+32 +;; @0034 v85 = load.i64 notrap aligned readonly can_move region0 v0+8 +;; @0034 v14 = load.i64 notrap aligned readonly can_move v85+32 ;; @0034 v13 = uextend.i64 v6 ;; @0034 v15 = iadd v14, v13 ;; @0034 v16 = load.i32 user2 region1 v15 @@ -53,52 +53,52 @@ ;; @0034 brif v18, block4, block3 ;; ;; block3: -;; @0034 v20 = load.i64 notrap aligned readonly can_move region2 v0+32 -;; @0034 v21 = load.i32 user2 region1 v20 -;; @0034 v25 = iconst.i64 16 -;; @0034 v26 = iadd.i64 v15, v25 ; v25 = 16 -;; @0034 store user2 region1 v21, v26 -;; v92 = iconst.i32 2 -;; v93 = bor.i32 v16, v92 ; v92 = 2 -;; @0034 store user2 region1 v93, v15 -;; @0034 v35 = iconst.i64 8 -;; @0034 v36 = iadd.i64 v15, v35 ; v35 = 8 -;; @0034 v37 = load.i64 user2 region1 v36 -;; @0034 v38 = iconst.i64 1 -;; @0034 v39 = iadd v37, v38 ; v38 = 1 -;; @0034 store user2 region1 v39, v36 -;; @0034 store.i32 user2 region1 v6, v20 -;; @0034 v47 = load.i32 notrap aligned v20+4 -;; v94 = iconst.i32 1 -;; v95 = iadd v47, v94 ; v94 = 1 -;; @0034 store notrap aligned v95, v20+4 -;; @0034 v57 = load.i32 notrap aligned v20+8 -;; @0034 v58 = iadd v57, v57 -;; @0034 v59 = iconst.i32 1024 -;; @0034 v60 = umax v58, v59 ; v59 = 1024 -;; @0034 v61 = icmp uge v95, v60 -;; @0034 brif v61, block5, block6 +;; @0034 v19 = load.i64 notrap aligned readonly can_move region2 v0+32 +;; @0034 v20 = load.i32 user2 region1 v19 +;; @0034 v24 = iconst.i64 16 +;; @0034 v25 = iadd.i64 v15, v24 ; v24 = 16 +;; @0034 store user2 region1 v20, v25 +;; v87 = iconst.i32 2 +;; v88 = bor.i32 v16, v87 ; v87 = 2 +;; @0034 store user2 region1 v88, v15 +;; @0034 v34 = iconst.i64 8 +;; @0034 v35 = iadd.i64 v15, v34 ; v34 = 8 +;; @0034 v36 = load.i64 user2 region1 v35 +;; @0034 v37 = iconst.i64 1 +;; @0034 v38 = iadd v36, v37 ; v37 = 1 +;; @0034 store user2 region1 v38, v35 +;; @0034 store.i32 user2 region1 v6, v19 +;; @0034 v45 = load.i32 notrap aligned v19+4 +;; v89 = iconst.i32 1 +;; v90 = iadd v45, v89 ; v89 = 1 +;; @0034 store notrap aligned v90, v19+4 +;; @0034 v52 = load.i32 notrap aligned v19+8 +;; @0034 v53 = iadd v52, v52 +;; @0034 v54 = iconst.i32 1024 +;; @0034 v55 = umax v53, v54 ; v54 = 1024 +;; @0034 v56 = icmp uge v90, v55 +;; @0034 brif v56, block5, block6 ;; ;; block5 cold: -;; @0034 v62 = call fn0(v0), stack_map=[i32 @ ss0+0] +;; @0034 v57 = call fn0(v0), stack_map=[i32 @ ss0+0] ;; @0034 jump block6 ;; ;; block6: ;; @0034 jump block4 ;; ;; block4: -;; v64 = load.i32 notrap v81 +;; v59 = load.i32 notrap v76 ;; @0036 jump block1 ;; ;; block1: -;; @0036 return v64 +;; @0036 return v59 ;; } ;; ;; function u0:1(i64 vmctx, i64, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/funcref-in-gc-heap-get.wat b/tests/disas/gc/drc/funcref-in-gc-heap-get.wat index 71ddc69387e6..f5a688d1821a 100644 --- a/tests/disas/gc/drc/funcref-in-gc-heap-get.wat +++ b/tests/disas/gc/drc/funcref-in-gc-heap-get.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/funcref-in-gc-heap-new.wat b/tests/disas/gc/drc/funcref-in-gc-heap-new.wat index 6ea1c1026338..9aa4e9c0729e 100644 --- a/tests/disas/gc/drc/funcref-in-gc-heap-new.wat +++ b/tests/disas/gc/drc/funcref-in-gc-heap-new.wat @@ -15,7 +15,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail ;; sig1 = (i64 vmctx, i64) -> i64 tail diff --git a/tests/disas/gc/drc/funcref-in-gc-heap-set.wat b/tests/disas/gc/drc/funcref-in-gc-heap-set.wat index 8eadb112d6cc..3ed7e59cadb8 100644 --- a/tests/disas/gc/drc/funcref-in-gc-heap-set.wat +++ b/tests/disas/gc/drc/funcref-in-gc-heap-set.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/i31ref-globals.wat b/tests/disas/gc/drc/i31ref-globals.wat index 9a98c5f368ae..bd4d4e9cfdd3 100644 --- a/tests/disas/gc/drc/i31ref-globals.wat +++ b/tests/disas/gc/drc/i31ref-globals.wat @@ -15,7 +15,7 @@ ;; function u0:0(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; stack_limit = gv2 @@ -33,7 +33,7 @@ ;; function u0:1(i64 vmctx, i64, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; stack_limit = gv2 diff --git a/tests/disas/gc/drc/multiple-array-get.wat b/tests/disas/gc/drc/multiple-array-get.wat index dfa414717b0e..70bd9ec9b637 100644 --- a/tests/disas/gc/drc/multiple-array-get.wat +++ b/tests/disas/gc/drc/multiple-array-get.wat @@ -14,7 +14,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/multiple-struct-get.wat b/tests/disas/gc/drc/multiple-struct-get.wat index 825d275cdaa8..887b49dd769a 100644 --- a/tests/disas/gc/drc/multiple-struct-get.wat +++ b/tests/disas/gc/drc/multiple-struct-get.wat @@ -15,7 +15,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/ref-cast.wat b/tests/disas/gc/drc/ref-cast.wat index 91c9b417aebb..61c158701d66 100644 --- a/tests/disas/gc/drc/ref-cast.wat +++ b/tests/disas/gc/drc/ref-cast.wat @@ -13,7 +13,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/ref-is-null.wat b/tests/disas/gc/drc/ref-is-null.wat index f0522da4e561..9fc032e491f1 100644 --- a/tests/disas/gc/drc/ref-is-null.wat +++ b/tests/disas/gc/drc/ref-is-null.wat @@ -13,7 +13,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -30,7 +30,7 @@ ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/gc/drc/ref-test-any.wat b/tests/disas/gc/drc/ref-test-any.wat index f74c61f39f86..3d6149ee0e0a 100644 --- a/tests/disas/gc/drc/ref-test-any.wat +++ b/tests/disas/gc/drc/ref-test-any.wat @@ -13,7 +13,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -30,7 +30,7 @@ ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/gc/drc/ref-test-array.wat b/tests/disas/gc/drc/ref-test-array.wat index fe23adee53a3..96f93b88f5b1 100644 --- a/tests/disas/gc/drc/ref-test-array.wat +++ b/tests/disas/gc/drc/ref-test-array.wat @@ -11,7 +11,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/ref-test-concrete-func-type.wat b/tests/disas/gc/drc/ref-test-concrete-func-type.wat index 80a2ef069ec3..4426059a776b 100644 --- a/tests/disas/gc/drc/ref-test-concrete-func-type.wat +++ b/tests/disas/gc/drc/ref-test-concrete-func-type.wat @@ -13,7 +13,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/gc/drc/ref-test-concrete-type.wat b/tests/disas/gc/drc/ref-test-concrete-type.wat index 028765828684..34f2c07fc33a 100644 --- a/tests/disas/gc/drc/ref-test-concrete-type.wat +++ b/tests/disas/gc/drc/ref-test-concrete-type.wat @@ -13,7 +13,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/ref-test-eq.wat b/tests/disas/gc/drc/ref-test-eq.wat index 6e1257cfeb8d..1383eebcbe45 100644 --- a/tests/disas/gc/drc/ref-test-eq.wat +++ b/tests/disas/gc/drc/ref-test-eq.wat @@ -11,7 +11,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/ref-test-i31.wat b/tests/disas/gc/drc/ref-test-i31.wat index b92f6debee73..960a1211ec28 100644 --- a/tests/disas/gc/drc/ref-test-i31.wat +++ b/tests/disas/gc/drc/ref-test-i31.wat @@ -10,7 +10,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/gc/drc/ref-test-none.wat b/tests/disas/gc/drc/ref-test-none.wat index 84f842acb3e2..1b63cbcf90bc 100644 --- a/tests/disas/gc/drc/ref-test-none.wat +++ b/tests/disas/gc/drc/ref-test-none.wat @@ -13,7 +13,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -28,7 +28,7 @@ ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/gc/drc/ref-test-struct.wat b/tests/disas/gc/drc/ref-test-struct.wat index 8068ff3e0532..d448f7b9b7fe 100644 --- a/tests/disas/gc/drc/ref-test-struct.wat +++ b/tests/disas/gc/drc/ref-test-struct.wat @@ -11,7 +11,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/struct-get.wat b/tests/disas/gc/drc/struct-get.wat index e34f7dc6ef7f..b03eeafcd1a4 100644 --- a/tests/disas/gc/drc/struct-get.wat +++ b/tests/disas/gc/drc/struct-get.wat @@ -27,7 +27,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -54,7 +54,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -82,7 +82,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -112,7 +112,7 @@ ;; region1 = 2147483648 "GcHeap" ;; region2 = 32 "VMContext+0x20" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -124,15 +124,15 @@ ;; ;; block0(v0: i64, v1: i64, v2: i32): ;; @004e trapz v2, user16 -;; @004e v95 = load.i64 notrap aligned readonly can_move region0 v0+8 -;; @004e v5 = load.i64 notrap aligned readonly can_move v95+32 +;; @004e v90 = load.i64 notrap aligned readonly can_move region0 v0+8 +;; @004e v5 = load.i64 notrap aligned readonly can_move v90+32 ;; @004e v4 = uextend.i64 v2 ;; @004e v6 = iadd v5, v4 ;; @004e v7 = iconst.i64 32 ;; @004e v8 = iadd v6, v7 ; v7 = 32 ;; @004e v9 = load.i32 user2 little region1 v8 -;; v84 = stack_addr.i64 ss0 -;; store notrap v9, v84 +;; v79 = stack_addr.i64 ss0 +;; store notrap v9, v79 ;; @004e v10 = iconst.i32 1 ;; @004e v11 = band v9, v10 ; v10 = 1 ;; @004e v12 = iconst.i32 0 @@ -150,43 +150,43 @@ ;; @004e brif v21, block4, block3 ;; ;; block3: -;; @004e v23 = load.i64 notrap aligned readonly can_move region2 v0+32 -;; @004e v24 = load.i32 user2 region1 v23 -;; @004e v28 = iconst.i64 16 -;; @004e v29 = iadd.i64 v18, v28 ; v28 = 16 -;; @004e store user2 region1 v24, v29 -;; v97 = iconst.i32 2 -;; v98 = bor.i32 v19, v97 ; v97 = 2 -;; @004e store user2 region1 v98, v18 -;; @004e v38 = iconst.i64 8 -;; @004e v39 = iadd.i64 v18, v38 ; v38 = 8 -;; @004e v40 = load.i64 user2 region1 v39 -;; @004e v41 = iconst.i64 1 -;; @004e v42 = iadd v40, v41 ; v41 = 1 -;; @004e store user2 region1 v42, v39 -;; @004e store.i32 user2 region1 v9, v23 -;; @004e v50 = load.i32 notrap aligned v23+4 -;; v99 = iconst.i32 1 -;; v100 = iadd v50, v99 ; v99 = 1 -;; @004e store notrap aligned v100, v23+4 -;; @004e v60 = load.i32 notrap aligned v23+8 -;; @004e v61 = iadd v60, v60 -;; @004e v62 = iconst.i32 1024 -;; @004e v63 = umax v61, v62 ; v62 = 1024 -;; @004e v64 = icmp uge v100, v63 -;; @004e brif v64, block5, block6 +;; @004e v22 = load.i64 notrap aligned readonly can_move region2 v0+32 +;; @004e v23 = load.i32 user2 region1 v22 +;; @004e v27 = iconst.i64 16 +;; @004e v28 = iadd.i64 v18, v27 ; v27 = 16 +;; @004e store user2 region1 v23, v28 +;; v92 = iconst.i32 2 +;; v93 = bor.i32 v19, v92 ; v92 = 2 +;; @004e store user2 region1 v93, v18 +;; @004e v37 = iconst.i64 8 +;; @004e v38 = iadd.i64 v18, v37 ; v37 = 8 +;; @004e v39 = load.i64 user2 region1 v38 +;; @004e v40 = iconst.i64 1 +;; @004e v41 = iadd v39, v40 ; v40 = 1 +;; @004e store user2 region1 v41, v38 +;; @004e store.i32 user2 region1 v9, v22 +;; @004e v48 = load.i32 notrap aligned v22+4 +;; v94 = iconst.i32 1 +;; v95 = iadd v48, v94 ; v94 = 1 +;; @004e store notrap aligned v95, v22+4 +;; @004e v55 = load.i32 notrap aligned v22+8 +;; @004e v56 = iadd v55, v55 +;; @004e v57 = iconst.i32 1024 +;; @004e v58 = umax v56, v57 ; v57 = 1024 +;; @004e v59 = icmp uge v95, v58 +;; @004e brif v59, block5, block6 ;; ;; block5 cold: -;; @004e v65 = call fn0(v0), stack_map=[i32 @ ss0+0] +;; @004e v60 = call fn0(v0), stack_map=[i32 @ ss0+0] ;; @004e jump block6 ;; ;; block6: ;; @004e jump block4 ;; ;; block4: -;; v67 = load.i32 notrap v84 +;; v62 = load.i32 notrap v79 ;; @0052 jump block1 ;; ;; block1: -;; @0052 return v67 +;; @0052 return v62 ;; } diff --git a/tests/disas/gc/drc/struct-new-default.wat b/tests/disas/gc/drc/struct-new-default.wat index 81819b859b8c..0b3a457d6dd1 100644 --- a/tests/disas/gc/drc/struct-new-default.wat +++ b/tests/disas/gc/drc/struct-new-default.wat @@ -16,7 +16,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/struct-new.wat b/tests/disas/gc/drc/struct-new.wat index dc6cf90a64bc..5ef6400fc363 100644 --- a/tests/disas/gc/drc/struct-new.wat +++ b/tests/disas/gc/drc/struct-new.wat @@ -17,7 +17,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/drc/struct-set.wat b/tests/disas/gc/drc/struct-set.wat index 0c704fe05177..37ba46dbaf64 100644 --- a/tests/disas/gc/drc/struct-set.wat +++ b/tests/disas/gc/drc/struct-set.wat @@ -23,7 +23,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -77,7 +77,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/array-fill.wat b/tests/disas/gc/null/array-fill.wat index 6d31effbafea..c76ea8ec43fa 100644 --- a/tests/disas/gc/null/array-fill.wat +++ b/tests/disas/gc/null/array-fill.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/array-get-s.wat b/tests/disas/gc/null/array-get-s.wat index 1483e6ccbd8d..c18c2d959a13 100644 --- a/tests/disas/gc/null/array-get-s.wat +++ b/tests/disas/gc/null/array-get-s.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/array-get-u.wat b/tests/disas/gc/null/array-get-u.wat index 9b4cf5d4b059..2f1c610ea6a6 100644 --- a/tests/disas/gc/null/array-get-u.wat +++ b/tests/disas/gc/null/array-get-u.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/array-get.wat b/tests/disas/gc/null/array-get.wat index af40d7fcc6e2..d84848974866 100644 --- a/tests/disas/gc/null/array-get.wat +++ b/tests/disas/gc/null/array-get.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/array-len.wat b/tests/disas/gc/null/array-len.wat index 03263d41e5dd..3b45b6b46102 100644 --- a/tests/disas/gc/null/array-len.wat +++ b/tests/disas/gc/null/array-len.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/array-new-fixed-of-gc-refs.wat b/tests/disas/gc/null/array-new-fixed-of-gc-refs.wat index 354b110a5b03..8b28d6047a07 100644 --- a/tests/disas/gc/null/array-new-fixed-of-gc-refs.wat +++ b/tests/disas/gc/null/array-new-fixed-of-gc-refs.wat @@ -18,7 +18,7 @@ ;; region2 = 2147483648 "GcHeap" ;; region3 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -35,7 +35,7 @@ ;; store notrap v3, v127 ;; v128 = stack_addr.i64 ss0 ;; store notrap v4, v128 -;; @0025 v18 = load.i64 notrap aligned readonly region1 v0+32 +;; @0025 v18 = load.i64 notrap aligned readonly can_move region1 v0+32 ;; @0025 v19 = load.i32 user2 region2 v18 ;; v158 = iconst.i32 7 ;; @0025 v22 = uadd_overflow_trap v19, v158, user18 ; v158 = 7 diff --git a/tests/disas/gc/null/array-new-fixed.wat b/tests/disas/gc/null/array-new-fixed.wat index 3b0f20049498..c9ec3b9301a9 100644 --- a/tests/disas/gc/null/array-new-fixed.wat +++ b/tests/disas/gc/null/array-new-fixed.wat @@ -15,7 +15,7 @@ ;; region2 = 2147483648 "GcHeap" ;; region3 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -26,7 +26,7 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64): -;; @0025 v18 = load.i64 notrap aligned readonly region1 v0+32 +;; @0025 v18 = load.i64 notrap aligned readonly can_move region1 v0+32 ;; @0025 v19 = load.i32 user2 region2 v18 ;; v149 = iconst.i32 7 ;; @0025 v22 = uadd_overflow_trap v19, v149, user18 ; v149 = 7 diff --git a/tests/disas/gc/null/array-new.wat b/tests/disas/gc/null/array-new.wat index 21b1564dd584..b01f59f12d82 100644 --- a/tests/disas/gc/null/array-new.wat +++ b/tests/disas/gc/null/array-new.wat @@ -15,7 +15,7 @@ ;; region2 = 2147483648 "GcHeap" ;; region3 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -39,7 +39,7 @@ ;; @0022 v14 = iconst.i32 -67108864 ;; @0022 v15 = band v12, v14 ; v14 = -67108864 ;; @0022 trapnz v15, user18 -;; @0022 v16 = load.i64 notrap aligned readonly region1 v0+32 +;; @0022 v16 = load.i64 notrap aligned readonly can_move region1 v0+32 ;; @0022 v17 = load.i32 user2 region2 v16 ;; v94 = iconst.i32 7 ;; @0022 v20 = uadd_overflow_trap v17, v94, user18 ; v94 = 7 diff --git a/tests/disas/gc/null/array-set.wat b/tests/disas/gc/null/array-set.wat index e7055bbb5ea5..ff664d2e8ffc 100644 --- a/tests/disas/gc/null/array-set.wat +++ b/tests/disas/gc/null/array-set.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/br-on-cast-fail.wat b/tests/disas/gc/null/br-on-cast-fail.wat index bb157449e0b6..50658a0e4afc 100644 --- a/tests/disas/gc/null/br-on-cast-fail.wat +++ b/tests/disas/gc/null/br-on-cast-fail.wat @@ -25,7 +25,7 @@ ;; region5 = 104 "VMContext+0x68" ;; region6 = 88 "VMContext+0x58" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -42,12 +42,12 @@ ;; block3: ;; @002e v8 = iconst.i32 1 ;; @002e v9 = band.i32 v2, v8 ; v8 = 1 -;; v30 = iconst.i32 0 -;; @002e brif v9, block5(v30), block4 ; v30 = 0 +;; v28 = iconst.i32 0 +;; @002e brif v9, block5(v28), block4 ; v28 = 0 ;; ;; block4: -;; @002e v28 = load.i64 notrap aligned readonly can_move region0 v0+8 -;; @002e v14 = load.i64 notrap aligned readonly can_move v28+32 +;; @002e v26 = load.i64 notrap aligned readonly can_move region0 v0+8 +;; @002e v14 = load.i64 notrap aligned readonly can_move v26+32 ;; @002e v13 = uextend.i64 v2 ;; @002e v15 = iadd v14, v13 ;; @002e v16 = iconst.i64 4 @@ -63,14 +63,14 @@ ;; @002e brif v21, block6, block2 ;; ;; block6: -;; @0034 v24 = load.i64 notrap aligned readonly can_move region4 v0+56 -;; @0034 v23 = load.i64 notrap aligned readonly can_move region3 v0+72 -;; @0034 call_indirect sig0, v24(v23, v0) +;; @0034 v23 = load.i64 notrap aligned readonly can_move region4 v0+56 +;; @0034 v22 = load.i64 notrap aligned readonly can_move region3 v0+72 +;; @0034 call_indirect sig0, v23(v22, v0) ;; @0036 return ;; ;; block2: -;; @0038 v27 = load.i64 notrap aligned readonly can_move region6 v0+88 -;; @0038 v26 = load.i64 notrap aligned readonly can_move region5 v0+104 -;; @0038 call_indirect sig0, v27(v26, v0) +;; @0038 v25 = load.i64 notrap aligned readonly can_move region6 v0+88 +;; @0038 v24 = load.i64 notrap aligned readonly can_move region5 v0+104 +;; @0038 call_indirect sig0, v25(v24, v0) ;; @003a return ;; } diff --git a/tests/disas/gc/null/br-on-cast.wat b/tests/disas/gc/null/br-on-cast.wat index aae92e91892a..8ff0034d42d0 100644 --- a/tests/disas/gc/null/br-on-cast.wat +++ b/tests/disas/gc/null/br-on-cast.wat @@ -25,7 +25,7 @@ ;; region5 = 104 "VMContext+0x68" ;; region6 = 88 "VMContext+0x58" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -42,12 +42,12 @@ ;; block3: ;; @002f v8 = iconst.i32 1 ;; @002f v9 = band.i32 v2, v8 ; v8 = 1 -;; v30 = iconst.i32 0 -;; @002f brif v9, block5(v30), block4 ; v30 = 0 +;; v28 = iconst.i32 0 +;; @002f brif v9, block5(v28), block4 ; v28 = 0 ;; ;; block4: -;; @002f v28 = load.i64 notrap aligned readonly can_move region0 v0+8 -;; @002f v14 = load.i64 notrap aligned readonly can_move v28+32 +;; @002f v26 = load.i64 notrap aligned readonly can_move region0 v0+8 +;; @002f v14 = load.i64 notrap aligned readonly can_move v26+32 ;; @002f v13 = uextend.i64 v2 ;; @002f v15 = iadd v14, v13 ;; @002f v16 = iconst.i64 4 @@ -63,14 +63,14 @@ ;; @002f brif v21, block2, block6 ;; ;; block6: -;; @0035 v24 = load.i64 notrap aligned readonly can_move region4 v0+56 -;; @0035 v23 = load.i64 notrap aligned readonly can_move region3 v0+72 -;; @0035 call_indirect sig0, v24(v23, v0) +;; @0035 v23 = load.i64 notrap aligned readonly can_move region4 v0+56 +;; @0035 v22 = load.i64 notrap aligned readonly can_move region3 v0+72 +;; @0035 call_indirect sig0, v23(v22, v0) ;; @0037 return ;; ;; block2: -;; @0039 v27 = load.i64 notrap aligned readonly can_move region6 v0+88 -;; @0039 v26 = load.i64 notrap aligned readonly can_move region5 v0+104 -;; @0039 call_indirect sig0, v27(v26, v0) +;; @0039 v25 = load.i64 notrap aligned readonly can_move region6 v0+88 +;; @0039 v24 = load.i64 notrap aligned readonly can_move region5 v0+104 +;; @0039 call_indirect sig0, v25(v24, v0) ;; @003b return ;; } diff --git a/tests/disas/gc/null/call-indirect-and-subtyping.wat b/tests/disas/gc/null/call-indirect-and-subtyping.wat index 2b22d5159587..cc2c2863cc01 100644 --- a/tests/disas/gc/null/call-indirect-and-subtyping.wat +++ b/tests/disas/gc/null/call-indirect-and-subtyping.wat @@ -21,7 +21,7 @@ ;; region1 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; region2 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+112 diff --git a/tests/disas/gc/null/externref-globals.wat b/tests/disas/gc/null/externref-globals.wat index 5c07d6545ca5..32a2c24c4dac 100644 --- a/tests/disas/gc/null/externref-globals.wat +++ b/tests/disas/gc/null/externref-globals.wat @@ -15,7 +15,7 @@ ;; function u0:0(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; stack_limit = gv2 @@ -33,7 +33,7 @@ ;; function u0:1(i64 vmctx, i64, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; stack_limit = gv2 diff --git a/tests/disas/gc/null/funcref-in-gc-heap-get.wat b/tests/disas/gc/null/funcref-in-gc-heap-get.wat index 26e52710a7e5..a97ee0722976 100644 --- a/tests/disas/gc/null/funcref-in-gc-heap-get.wat +++ b/tests/disas/gc/null/funcref-in-gc-heap-get.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/funcref-in-gc-heap-new.wat b/tests/disas/gc/null/funcref-in-gc-heap-new.wat index 286f8513fedd..fc3e903c2c3d 100644 --- a/tests/disas/gc/null/funcref-in-gc-heap-new.wat +++ b/tests/disas/gc/null/funcref-in-gc-heap-new.wat @@ -15,7 +15,7 @@ ;; region2 = 2147483648 "GcHeap" ;; region3 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i64) -> i8 tail ;; sig1 = (i64 vmctx, i64) -> i64 tail @@ -24,7 +24,7 @@ ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i64): -;; @0020 v8 = load.i64 notrap aligned readonly region1 v0+32 +;; @0020 v8 = load.i64 notrap aligned readonly can_move region1 v0+32 ;; @0020 v9 = load.i32 user2 region2 v8 ;; v40 = iconst.i32 7 ;; @0020 v12 = uadd_overflow_trap v9, v40, user18 ; v40 = 7 diff --git a/tests/disas/gc/null/funcref-in-gc-heap-set.wat b/tests/disas/gc/null/funcref-in-gc-heap-set.wat index 911fa7a5d751..14a86ff3adf2 100644 --- a/tests/disas/gc/null/funcref-in-gc-heap-set.wat +++ b/tests/disas/gc/null/funcref-in-gc-heap-set.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/i31ref-globals.wat b/tests/disas/gc/null/i31ref-globals.wat index 2b17dc76f453..d4d2e830687f 100644 --- a/tests/disas/gc/null/i31ref-globals.wat +++ b/tests/disas/gc/null/i31ref-globals.wat @@ -15,7 +15,7 @@ ;; function u0:0(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; stack_limit = gv2 @@ -33,7 +33,7 @@ ;; function u0:1(i64 vmctx, i64, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; stack_limit = gv2 diff --git a/tests/disas/gc/null/multiple-array-get.wat b/tests/disas/gc/null/multiple-array-get.wat index 8b578f5dfe31..b0faac8dc350 100644 --- a/tests/disas/gc/null/multiple-array-get.wat +++ b/tests/disas/gc/null/multiple-array-get.wat @@ -14,7 +14,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/multiple-struct-get.wat b/tests/disas/gc/null/multiple-struct-get.wat index 5967e59ec333..d33da9f636fb 100644 --- a/tests/disas/gc/null/multiple-struct-get.wat +++ b/tests/disas/gc/null/multiple-struct-get.wat @@ -15,7 +15,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/ref-cast.wat b/tests/disas/gc/null/ref-cast.wat index 7ffed2108228..d62626ce69fa 100644 --- a/tests/disas/gc/null/ref-cast.wat +++ b/tests/disas/gc/null/ref-cast.wat @@ -13,7 +13,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/ref-is-null.wat b/tests/disas/gc/null/ref-is-null.wat index d9c0a912e180..f191dc70afd5 100644 --- a/tests/disas/gc/null/ref-is-null.wat +++ b/tests/disas/gc/null/ref-is-null.wat @@ -13,7 +13,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -30,7 +30,7 @@ ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/gc/null/ref-test-any.wat b/tests/disas/gc/null/ref-test-any.wat index 0f7a5eaf8b70..3f107a4ec889 100644 --- a/tests/disas/gc/null/ref-test-any.wat +++ b/tests/disas/gc/null/ref-test-any.wat @@ -13,7 +13,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -30,7 +30,7 @@ ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/gc/null/ref-test-array.wat b/tests/disas/gc/null/ref-test-array.wat index 569ae0aee6ee..506b3e5cb5a2 100644 --- a/tests/disas/gc/null/ref-test-array.wat +++ b/tests/disas/gc/null/ref-test-array.wat @@ -11,7 +11,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/ref-test-concrete-func-type.wat b/tests/disas/gc/null/ref-test-concrete-func-type.wat index 4e2edc39bd00..abf37ee191c6 100644 --- a/tests/disas/gc/null/ref-test-concrete-func-type.wat +++ b/tests/disas/gc/null/ref-test-concrete-func-type.wat @@ -13,7 +13,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/gc/null/ref-test-concrete-type.wat b/tests/disas/gc/null/ref-test-concrete-type.wat index fe7938312866..a43634d12666 100644 --- a/tests/disas/gc/null/ref-test-concrete-type.wat +++ b/tests/disas/gc/null/ref-test-concrete-type.wat @@ -13,7 +13,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/ref-test-eq.wat b/tests/disas/gc/null/ref-test-eq.wat index 5223ed31ed45..22253984a54a 100644 --- a/tests/disas/gc/null/ref-test-eq.wat +++ b/tests/disas/gc/null/ref-test-eq.wat @@ -11,7 +11,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/ref-test-i31.wat b/tests/disas/gc/null/ref-test-i31.wat index a3a5c8cc07e4..1b4dda53c8b0 100644 --- a/tests/disas/gc/null/ref-test-i31.wat +++ b/tests/disas/gc/null/ref-test-i31.wat @@ -10,7 +10,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/gc/null/ref-test-none.wat b/tests/disas/gc/null/ref-test-none.wat index 28b5231e9354..2ccd6ef99f6a 100644 --- a/tests/disas/gc/null/ref-test-none.wat +++ b/tests/disas/gc/null/ref-test-none.wat @@ -13,7 +13,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -28,7 +28,7 @@ ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/gc/null/ref-test-struct.wat b/tests/disas/gc/null/ref-test-struct.wat index f28726afd574..6cf318530e48 100644 --- a/tests/disas/gc/null/ref-test-struct.wat +++ b/tests/disas/gc/null/ref-test-struct.wat @@ -11,7 +11,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/struct-get-guard-pages.wat b/tests/disas/gc/null/struct-get-guard-pages.wat index adef362a7c4f..8d8b791fe1a1 100644 --- a/tests/disas/gc/null/struct-get-guard-pages.wat +++ b/tests/disas/gc/null/struct-get-guard-pages.wat @@ -27,7 +27,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -54,7 +54,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -82,7 +82,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -110,7 +110,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/struct-get-no-guard-pages.wat b/tests/disas/gc/null/struct-get-no-guard-pages.wat index f8b4e829f16d..7a1ff0e59d38 100644 --- a/tests/disas/gc/null/struct-get-no-guard-pages.wat +++ b/tests/disas/gc/null/struct-get-no-guard-pages.wat @@ -27,7 +27,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -60,7 +60,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -94,7 +94,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -128,7 +128,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/struct-get.wat b/tests/disas/gc/null/struct-get.wat index 7bda83f2b563..28ee96a58aa8 100644 --- a/tests/disas/gc/null/struct-get.wat +++ b/tests/disas/gc/null/struct-get.wat @@ -27,7 +27,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -54,7 +54,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -82,7 +82,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -110,7 +110,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/struct-new-default.wat b/tests/disas/gc/null/struct-new-default.wat index 7732d0f53776..f546fa684079 100644 --- a/tests/disas/gc/null/struct-new-default.wat +++ b/tests/disas/gc/null/struct-new-default.wat @@ -17,14 +17,14 @@ ;; region2 = 2147483648 "GcHeap" ;; region3 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i64) -> i8 tail ;; fn0 = colocated u805306368:23 sig0 ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64): -;; @0021 v10 = load.i64 notrap aligned readonly region1 v0+32 +;; @0021 v10 = load.i64 notrap aligned readonly can_move region1 v0+32 ;; @0021 v11 = load.i32 user2 region2 v10 ;; v43 = iconst.i32 7 ;; @0021 v14 = uadd_overflow_trap v11, v43, user18 ; v43 = 7 diff --git a/tests/disas/gc/null/struct-new.wat b/tests/disas/gc/null/struct-new.wat index f1073c17fa43..8cb6dd40ecf8 100644 --- a/tests/disas/gc/null/struct-new.wat +++ b/tests/disas/gc/null/struct-new.wat @@ -18,7 +18,7 @@ ;; region2 = 2147483648 "GcHeap" ;; region3 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i64) -> i8 tail ;; fn0 = colocated u805306368:23 sig0 @@ -27,7 +27,7 @@ ;; block0(v0: i64, v1: i64, v2: f32, v3: i32, v4: i32): ;; v40 = stack_addr.i64 ss0 ;; store notrap v4, v40 -;; @002a v10 = load.i64 notrap aligned readonly region1 v0+32 +;; @002a v10 = load.i64 notrap aligned readonly can_move region1 v0+32 ;; @002a v11 = load.i32 user2 region2 v10 ;; v47 = iconst.i32 7 ;; @002a v14 = uadd_overflow_trap v11, v47, user18 ; v47 = 7 diff --git a/tests/disas/gc/null/struct-set.wat b/tests/disas/gc/null/struct-set.wat index 636fbc6ce12e..1f19bfca6e56 100644 --- a/tests/disas/gc/null/struct-set.wat +++ b/tests/disas/gc/null/struct-set.wat @@ -23,7 +23,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -77,7 +77,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/null/v128-fields.wat b/tests/disas/gc/null/v128-fields.wat index 9b15dfc8c711..84ab4b877416 100644 --- a/tests/disas/gc/null/v128-fields.wat +++ b/tests/disas/gc/null/v128-fields.wat @@ -15,7 +15,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/ref-test-cast-final-type.wat b/tests/disas/gc/ref-test-cast-final-type.wat index a3c303d10e05..4fdaad1e7ba0 100644 --- a/tests/disas/gc/ref-test-cast-final-type.wat +++ b/tests/disas/gc/ref-test-cast-final-type.wat @@ -19,7 +19,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 @@ -64,7 +64,7 @@ ;; region1 = 40 "VMContext+0x28" ;; region2 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 diff --git a/tests/disas/gc/struct-new-default.wat b/tests/disas/gc/struct-new-default.wat index c33edbd8e78e..0a710fb91331 100644 --- a/tests/disas/gc/struct-new-default.wat +++ b/tests/disas/gc/struct-new-default.wat @@ -18,7 +18,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail ;; fn0 = colocated u805306368:24 sig0 @@ -39,7 +39,7 @@ ;; block2: ;; v63 = iconst.i32 48 ;; v61 = iadd.i32 v9, v63 ; v63 = 48 -;; @0023 store notrap aligned region1 v61, v8 +;; @0023 store notrap aligned v61, v8 ;; v64 = iconst.i32 -1342177246 ;; v65 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v66 = load.i64 notrap aligned readonly can_move v65+32 diff --git a/tests/disas/gc/struct-new.wat b/tests/disas/gc/struct-new.wat index 727c3366d7e1..559c8b55a58f 100644 --- a/tests/disas/gc/struct-new.wat +++ b/tests/disas/gc/struct-new.wat @@ -18,7 +18,7 @@ ;; region2 = 40 "VMContext+0x28" ;; region3 = 2147483648 "GcHeap" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i32, i32, i32, i32) -> i32 tail ;; fn0 = colocated u805306368:24 sig0 @@ -40,7 +40,7 @@ ;; block2: ;; v63 = iconst.i32 32 ;; v61 = iadd.i32 v8, v63 ; v63 = 32 -;; @002a store notrap aligned region1 v61, v7 +;; @002a store notrap aligned v61, v7 ;; v64 = iconst.i32 -1342177246 ;; v65 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; v66 = load.i64 notrap aligned readonly can_move v65+32 diff --git a/tests/disas/gc/typed-select-and-stack-maps.wat b/tests/disas/gc/typed-select-and-stack-maps.wat index 336800ae5738..f829089fc71f 100644 --- a/tests/disas/gc/typed-select-and-stack-maps.wat +++ b/tests/disas/gc/typed-select-and-stack-maps.wat @@ -47,24 +47,23 @@ ;; region3 = 72 "VMContext+0x48" ;; region4 = 56 "VMContext+0x38" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 -;; gv3 = vmctx ;; sig0 = (i64 vmctx, i64) tail ;; sig1 = (i64 vmctx, i64, i32) tail ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32): ;; @0049 v5 = select v4, v2, v3 -;; v14 = stack_addr.i64 ss0 -;; store notrap v5, v14 -;; @004c v8 = load.i64 notrap aligned readonly can_move region2 v0+88 -;; @004c v7 = load.i64 notrap aligned readonly can_move region1 v0+104 -;; @004c call_indirect sig0, v8(v7, v0), stack_map=[i32 @ ss0+0] -;; v13 = load.i32 notrap v14 -;; @004e v11 = load.i64 notrap aligned readonly can_move region4 v0+56 -;; @004e v10 = load.i64 notrap aligned readonly can_move region3 v0+72 -;; @004e call_indirect sig1, v11(v10, v0, v13) +;; v12 = stack_addr.i64 ss0 +;; store notrap v5, v12 +;; @004c v7 = load.i64 notrap aligned readonly can_move region2 v0+88 +;; @004c v6 = load.i64 notrap aligned readonly can_move region1 v0+104 +;; @004c call_indirect sig0, v7(v6, v0), stack_map=[i32 @ ss0+0] +;; v11 = load.i32 notrap v12 +;; @004e v9 = load.i64 notrap aligned readonly can_move region4 v0+56 +;; @004e v8 = load.i64 notrap aligned readonly can_move region3 v0+72 +;; @004e call_indirect sig1, v9(v8, v0, v11) ;; @0050 jump block1 ;; ;; block1: @@ -78,21 +77,20 @@ ;; region3 = 72 "VMContext+0x48" ;; region4 = 56 "VMContext+0x38" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 -;; gv3 = vmctx ;; sig0 = (i64 vmctx, i64) tail ;; sig1 = (i64 vmctx, i64, i32) tail ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32): -;; @005c v8 = load.i64 notrap aligned readonly can_move region2 v0+88 -;; @005c v7 = load.i64 notrap aligned readonly can_move region1 v0+104 -;; @005c call_indirect sig0, v8(v7, v0) -;; @005e v11 = load.i64 notrap aligned readonly can_move region4 v0+56 -;; @005e v10 = load.i64 notrap aligned readonly can_move region3 v0+72 +;; @005c v7 = load.i64 notrap aligned readonly can_move region2 v0+88 +;; @005c v6 = load.i64 notrap aligned readonly can_move region1 v0+104 +;; @005c call_indirect sig0, v7(v6, v0) +;; @005e v9 = load.i64 notrap aligned readonly can_move region4 v0+56 +;; @005e v8 = load.i64 notrap aligned readonly can_move region3 v0+72 ;; @0059 v5 = select v4, v2, v3 -;; @005e call_indirect sig1, v11(v10, v0, v5) +;; @005e call_indirect sig1, v9(v8, v0, v5) ;; @0060 jump block1 ;; ;; block1: diff --git a/tests/disas/global-get.wat b/tests/disas/global-get.wat index b734d098b5f8..1382f5968553 100644 --- a/tests/disas/global-get.wat +++ b/tests/disas/global-get.wat @@ -35,7 +35,7 @@ ;; region1 = 48 "VMContext+0x30" ;; region2 = 1610612736 "PublicGlobal" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region1 gv3+48 @@ -55,7 +55,7 @@ ;; region1 = 72 "VMContext+0x48" ;; region2 = 1610612736 "PublicGlobal" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region1 gv3+72 @@ -73,7 +73,7 @@ ;; function u0:2(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -89,7 +89,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1879048193 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(1))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; stack_limit = gv2 diff --git a/tests/disas/globals.wat b/tests/disas/globals.wat index 2e29b3f6bedc..459b9d32c047 100644 --- a/tests/disas/globals.wat +++ b/tests/disas/globals.wat @@ -14,7 +14,7 @@ ;; region1 = 1879048192 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))" ;; region2 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i128-cmp.wat b/tests/disas/i128-cmp.wat index dba8ba138f9a..edadf0657b43 100644 --- a/tests/disas/i128-cmp.wat +++ b/tests/disas/i128-cmp.wat @@ -102,7 +102,7 @@ ;; function u0:0(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -120,7 +120,7 @@ ;; function u0:1(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -138,7 +138,7 @@ ;; function u0:2(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -156,7 +156,7 @@ ;; function u0:3(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -174,7 +174,7 @@ ;; function u0:4(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -192,7 +192,7 @@ ;; function u0:5(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -210,7 +210,7 @@ ;; function u0:6(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -228,7 +228,7 @@ ;; function u0:7(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/i32-load.wat b/tests/disas/i32-load.wat index 4ac6e43a0d20..f91366cb37c2 100644 --- a/tests/disas/i32-load.wat +++ b/tests/disas/i32-load.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i32-load16-s.wat b/tests/disas/i32-load16-s.wat index 5455eed3436b..5c31ea5ddf92 100644 --- a/tests/disas/i32-load16-s.wat +++ b/tests/disas/i32-load16-s.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i32-load16-u.wat b/tests/disas/i32-load16-u.wat index 2ee87aee1442..c2c02edbced9 100644 --- a/tests/disas/i32-load16-u.wat +++ b/tests/disas/i32-load16-u.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i32-load8-s.wat b/tests/disas/i32-load8-s.wat index 3d3549dc4885..ab363ac833c7 100644 --- a/tests/disas/i32-load8-s.wat +++ b/tests/disas/i32-load8-s.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i32-load8-u.wat b/tests/disas/i32-load8-u.wat index 35752704dcd9..ab571b728ef5 100644 --- a/tests/disas/i32-load8-u.wat +++ b/tests/disas/i32-load8-u.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i32-store.wat b/tests/disas/i32-store.wat index 53dd61d9a3a0..b0b8211b2ac5 100644 --- a/tests/disas/i32-store.wat +++ b/tests/disas/i32-store.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i32-store16.wat b/tests/disas/i32-store16.wat index 7c57c06b6549..a14212a53b1e 100644 --- a/tests/disas/i32-store16.wat +++ b/tests/disas/i32-store16.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i32-store8.wat b/tests/disas/i32-store8.wat index 0afc742272e4..0e60fccd37ac 100644 --- a/tests/disas/i32-store8.wat +++ b/tests/disas/i32-store8.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i64-load.wat b/tests/disas/i64-load.wat index 3279cee6f805..d6856944697a 100644 --- a/tests/disas/i64-load.wat +++ b/tests/disas/i64-load.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i64-load16-s.wat b/tests/disas/i64-load16-s.wat index c0306bcb614d..eb29bcd4b0a8 100644 --- a/tests/disas/i64-load16-s.wat +++ b/tests/disas/i64-load16-s.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i64-load16-u.wat b/tests/disas/i64-load16-u.wat index 1324d6c160a5..da723a7ccdd4 100644 --- a/tests/disas/i64-load16-u.wat +++ b/tests/disas/i64-load16-u.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i64-load8-s.wat b/tests/disas/i64-load8-s.wat index 1d71f1eb9c4d..1ce688239bb0 100644 --- a/tests/disas/i64-load8-s.wat +++ b/tests/disas/i64-load8-s.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i64-load8-u.wat b/tests/disas/i64-load8-u.wat index a36d5a6d0704..7b9c9e2e6b42 100644 --- a/tests/disas/i64-load8-u.wat +++ b/tests/disas/i64-load8-u.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i64-store.wat b/tests/disas/i64-store.wat index d9527062dd1d..c2c3b6588dbd 100644 --- a/tests/disas/i64-store.wat +++ b/tests/disas/i64-store.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i64-store16.wat b/tests/disas/i64-store16.wat index 35d41ce072e2..da2684a20bff 100644 --- a/tests/disas/i64-store16.wat +++ b/tests/disas/i64-store16.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i64-store32.wat b/tests/disas/i64-store32.wat index d35f2573de1c..f16dc1515e34 100644 --- a/tests/disas/i64-store32.wat +++ b/tests/disas/i64-store32.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/i64-store8.wat b/tests/disas/i64-store8.wat index 886b2cd9744f..a012e5088811 100644 --- a/tests/disas/i64-store8.wat +++ b/tests/disas/i64-store8.wat @@ -13,7 +13,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/icall-loop.wat b/tests/disas/icall-loop.wat index 2763056f2ef0..76ae5c4ef3b4 100644 --- a/tests/disas/icall-loop.wat +++ b/tests/disas/icall-loop.wat @@ -27,7 +27,7 @@ ;; region1 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; region2 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+48 @@ -78,7 +78,7 @@ ;; region1 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; region2 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+48 diff --git a/tests/disas/icall-simd.wat b/tests/disas/icall-simd.wat index 7255d0688804..97360774e099 100644 --- a/tests/disas/icall-simd.wat +++ b/tests/disas/icall-simd.wat @@ -13,7 +13,7 @@ ;; region1 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; region2 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+48 diff --git a/tests/disas/icall.wat b/tests/disas/icall.wat index 62ef84f7501c..9d69fd746e11 100644 --- a/tests/disas/icall.wat +++ b/tests/disas/icall.wat @@ -13,7 +13,7 @@ ;; region1 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; region2 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+48 diff --git a/tests/disas/idempotent-store.wat b/tests/disas/idempotent-store.wat index 9debc219db68..e9ab2e468209 100644 --- a/tests/disas/idempotent-store.wat +++ b/tests/disas/idempotent-store.wat @@ -18,7 +18,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/if-reachability-translation-0.wat b/tests/disas/if-reachability-translation-0.wat index 24818e284347..8c899b7713b5 100644 --- a/tests/disas/if-reachability-translation-0.wat +++ b/tests/disas/if-reachability-translation-0.wat @@ -16,7 +16,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/if-reachability-translation-1.wat b/tests/disas/if-reachability-translation-1.wat index a4cea95de1ce..6da5b6b296ab 100644 --- a/tests/disas/if-reachability-translation-1.wat +++ b/tests/disas/if-reachability-translation-1.wat @@ -16,7 +16,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/if-reachability-translation-2.wat b/tests/disas/if-reachability-translation-2.wat index e181205d02b9..e046c7521a15 100644 --- a/tests/disas/if-reachability-translation-2.wat +++ b/tests/disas/if-reachability-translation-2.wat @@ -16,7 +16,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/if-reachability-translation-3.wat b/tests/disas/if-reachability-translation-3.wat index c66733a1291b..80172fdc7d00 100644 --- a/tests/disas/if-reachability-translation-3.wat +++ b/tests/disas/if-reachability-translation-3.wat @@ -16,7 +16,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/if-reachability-translation-4.wat b/tests/disas/if-reachability-translation-4.wat index 20dda3a11caa..b49357ced58d 100644 --- a/tests/disas/if-reachability-translation-4.wat +++ b/tests/disas/if-reachability-translation-4.wat @@ -16,7 +16,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/if-reachability-translation-5.wat b/tests/disas/if-reachability-translation-5.wat index 71c5c3549468..da42381e71b2 100644 --- a/tests/disas/if-reachability-translation-5.wat +++ b/tests/disas/if-reachability-translation-5.wat @@ -18,7 +18,7 @@ ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/if-reachability-translation-6.wat b/tests/disas/if-reachability-translation-6.wat index d57509557d39..b4ca3fbbcf1f 100644 --- a/tests/disas/if-reachability-translation-6.wat +++ b/tests/disas/if-reachability-translation-6.wat @@ -18,7 +18,7 @@ ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/if-unreachable-else-params-2.wat b/tests/disas/if-unreachable-else-params-2.wat index 3e0cb0a5f8fd..7d432a394ab0 100644 --- a/tests/disas/if-unreachable-else-params-2.wat +++ b/tests/disas/if-unreachable-else-params-2.wat @@ -23,7 +23,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 536870912 "PublicMemory" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/if-unreachable-else-params.wat b/tests/disas/if-unreachable-else-params.wat index b1fc786a1ec7..d1148860054e 100644 --- a/tests/disas/if-unreachable-else-params.wat +++ b/tests/disas/if-unreachable-else-params.wat @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 536870912 "PublicMemory" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/indirect-call-no-caching.wat b/tests/disas/indirect-call-no-caching.wat index ae42c54f4c27..441373a57356 100644 --- a/tests/disas/indirect-call-no-caching.wat +++ b/tests/disas/indirect-call-no-caching.wat @@ -23,7 +23,7 @@ ;; function u0:0(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -38,7 +38,7 @@ ;; function u0:1(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -53,7 +53,7 @@ ;; function u0:2(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -70,7 +70,7 @@ ;; region1 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; region2 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+48 diff --git a/tests/disas/intra-module-inlining.wat b/tests/disas/intra-module-inlining.wat index 1f176031f9ea..2641059275a0 100644 --- a/tests/disas/intra-module-inlining.wat +++ b/tests/disas/intra-module-inlining.wat @@ -12,7 +12,7 @@ ;; function u0:0(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -27,10 +27,10 @@ ;; function u0:1(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx -;; gv4 = load.i64 notrap aligned readonly region0 gv3+8 +;; gv4 = load.i64 notrap aligned readonly can_move region0 gv3+8 ;; gv5 = load.i64 notrap aligned gv4+24 ;; sig0 = (i64 vmctx, i64) -> i32 tail ;; fn0 = colocated u0:0 sig0 diff --git a/tests/disas/issue-10929-v128-icmp-egraphs.wat b/tests/disas/issue-10929-v128-icmp-egraphs.wat index a4454ad32438..c3359e3637ff 100644 --- a/tests/disas/issue-10929-v128-icmp-egraphs.wat +++ b/tests/disas/issue-10929-v128-icmp-egraphs.wat @@ -13,7 +13,7 @@ ;; function u0:0(i64 vmctx, i64, i8x16) -> i8x16 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; const0 = 0xffffffffffffffffffffffffffffffff ;; stack_limit = gv2 diff --git a/tests/disas/issue-12808.wat b/tests/disas/issue-12808.wat index f688a83ac83b..e638c097ec15 100644 --- a/tests/disas/issue-12808.wat +++ b/tests/disas/issue-12808.wat @@ -23,23 +23,23 @@ ;; 21: movq %rdi, (%rsp) ;; nopl (%rax, %rax) ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x1f, slot at FP-0x30, locals , stack -;; ╰─╼ breakpoint patch: wasm PC 0x1f, patch bytes [232, 227, 1, 0, 0] +;; ╰─╼ breakpoint patch: wasm PC 0x1f, patch bytes [232, 233, 1, 0, 0] ;; movl $0, 8(%rsp) ;; nopl (%rax, %rax) ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x21, slot at FP-0x30, locals , stack I32 @ slot+0x8 -;; ╰─╼ breakpoint patch: wasm PC 0x21, patch bytes [232, 214, 1, 0, 0] +;; ╰─╼ breakpoint patch: wasm PC 0x21, patch bytes [232, 220, 1, 0, 0] ;; movl $0, 0xc(%rsp) ;; nopl (%rax, %rax) ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x23, slot at FP-0x30, locals , stack I32 @ slot+0x8, I32 @ slot+0xc -;; ╰─╼ breakpoint patch: wasm PC 0x23, patch bytes [232, 201, 1, 0, 0] +;; ╰─╼ breakpoint patch: wasm PC 0x23, patch bytes [232, 207, 1, 0, 0] ;; movl $0, 0x10(%rsp) ;; nopl (%rax, %rax) ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x25, slot at FP-0x30, locals , stack I32 @ slot+0x8, I32 @ slot+0xc, I32 @ slot+0x10 -;; ╰─╼ breakpoint patch: wasm PC 0x25, patch bytes [232, 188, 1, 0, 0] +;; ╰─╼ breakpoint patch: wasm PC 0x25, patch bytes [232, 194, 1, 0, 0] ;; movl $0, 0x14(%rsp) ;; nopl (%rax, %rax) ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x27, slot at FP-0x30, locals , stack I32 @ slot+0x8, I32 @ slot+0xc, I32 @ slot+0x10, I32 @ slot+0x14 -;; ╰─╼ breakpoint patch: wasm PC 0x27, patch bytes [232, 175, 1, 0, 0] +;; ╰─╼ breakpoint patch: wasm PC 0x27, patch bytes [232, 181, 1, 0, 0] ;; movq 0x30(%rdi), %rax ;; movq (%rax), %rcx ;; xorl %eax, %eax @@ -48,7 +48,7 @@ ;; movq %rax, %rcx ;; nopl (%rax, %rax) ;; ├─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x2b, slot at FP-0x30, locals , stack I32 @ slot+0x8, I32 @ slot+0xc -;; ╰─╼ breakpoint patch: wasm PC 0x2b, patch bytes [232, 150, 1, 0, 0] +;; ╰─╼ breakpoint patch: wasm PC 0x2b, patch bytes [232, 156, 1, 0, 0] ;; xorl %eax, %eax ;; movl $0, 8(%rsp) ;; movl %ecx, 0xc(%rsp) @@ -59,8 +59,8 @@ ;; retq ;; 93: movq %rdi, %r14 ;; 96: xorl %esi, %esi -;; 98: callq 0x1af +;; 98: callq 0x1b5 ;; 9d: movq %r14, %rdi -;; a0: callq 0x1e0 +;; a0: callq 0x1e6 ;; ╰─╼ debug frame state (after previous inst): func key DefinedWasmFunction(StaticModuleIndex(0), DefinedFuncIndex(0)), wasm PC 0x1e, slot at FP-0x30, locals , stack ;; a5: ud2 diff --git a/tests/disas/issue-5696.wat b/tests/disas/issue-5696.wat index 813f816b6117..c5898b9e5f52 100644 --- a/tests/disas/issue-5696.wat +++ b/tests/disas/issue-5696.wat @@ -12,7 +12,7 @@ ;; function u0:0(i64 vmctx, i64, i64) -> i64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat index 090981c1e999..8eaf7d60a091 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat index 0cd9281cf004..7078069400fc 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -51,7 +51,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat index 5f7c1d289457..b9dab5938138 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -51,7 +51,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat index 89be900a2b1c..4fddfd54e90a 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -47,7 +47,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat index 471c2a890138..a3e9dc74401d 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -51,7 +51,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat index 60bb0f0e0c65..248eb63decdf 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -51,7 +51,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat index 4262f6459927..eb3f266406bc 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat index b6d1e7bb15b4..117af2e793b1 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -52,7 +52,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat index e28779814042..4edba4526bc5 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -52,7 +52,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat index 899cbf468600..c444785d4615 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat index e2faf892604e..2af44718c27e 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -52,7 +52,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat index e9834e48ae7a..07876326b8cc 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -52,7 +52,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat index 0abe2328828a..2527b20a527e 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -47,7 +47,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat index 111691e5fd89..c24f43b0def9 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat index 3bc452a2e82b..ecd9852edd8d 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat index 0a126f3a51c4..ba9eecf4ff07 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -47,7 +47,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat index 94da469f9b74..5a93749b4f64 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat index 214a62bc176c..ce834ac90979 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat index b8c708a71314..e69b248355c6 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat index f08e1eee5735..2b86148a0b7b 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat index 4e9f8a2b1471..ccf1dd16c341 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat index ad70cdced436..220694f8b858 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat index ec9ccc51f2f5..82aeb65f8b47 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat index d982c520854d..76f5c45efb53 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat index 7f882c3ee839..bb4fdfcbf272 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat index 14da837a3a08..a9f27c4759c0 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat index 9d58fef8cf0b..0ace7e9c2eff 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat index 68b91370933f..ec475cd42ae1 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat index 4806bf2942fb..ef7985a06636 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat index fe0dff39cb85..4761768d3bd0 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat index 2a921464ad01..91bb5db67c7e 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat index dd988e65a776..d40111611442 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -51,7 +51,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat index f15ace59fa75..7e9f2d58e2f2 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -51,7 +51,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat index 72bc1195c919..3c33dbf2b11d 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -47,7 +47,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat index 0795fac6457c..551c72baa195 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -51,7 +51,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat index d8ba2c09cdbd..e1b8aad98eb3 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -51,7 +51,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat index 7672bc24a0b4..1b43916d9d37 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat index c6cb4132c2f2..b9e824ead453 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat index 844e6a741418..ca3e9a39446e 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat index 8c036af6feba..d2cd5e482fb1 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat index 2d109779126e..263f96ce389b 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat index 317281b357f0..9cbf6333af28 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat index 3e7abe50a836..6691f9175e79 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -47,7 +47,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat index 366d4f6abeea..f496c499082f 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat index ad5059ac4ff3..f7f1d69fe43e 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat index 872f8086b8f7..27fb1f6cd88c 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -47,7 +47,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat index c5065d2edee9..9f487f074a7a 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat index 7e855d6062f8..952116a6c20f 100644 --- a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat index 6d38b4edc610..6843418e3061 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -47,7 +47,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat index 4b03e33c90c4..bb0b6d9397c7 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat index efc88154a58f..7fda5aa77ae4 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat index 6a47fd19e669..fcb383d4357a 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -44,7 +44,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat index 954407cc0c64..e8738775d4fb 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat index 6b01e0b2e0d5..5bb476acded3 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat index 1a711cc2a404..09f73080fdd4 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat index 3958b81ee61a..bde19aea0cf1 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat index 708fdff3cc06..e7275ab13b8c 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat index 9b82b7278490..16d79039cf58 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -44,7 +44,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat index b1efa0fb3790..01c4eb5368b8 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat index 3435a49f4ef7..5ac55c6dd244 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat index a5ab80397f41..541f4a51edcf 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -44,7 +44,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat index 31d22b10d968..710f04341cf8 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat index 62fe937b24c5..99c7c51bcd05 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat index ceabd4d0e4f2..f6dd84c1be6a 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -44,7 +44,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat index 4847f5bcc491..c2a2fa48069f 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat index 2ed8c79ef7ac..517d4170d755 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat index 43f0cd509bca..d9e32704cf46 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -44,7 +44,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat index 0980113295fb..ab5dc96f9aaa 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat index 907a23e76fc6..485c1c413167 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat index 531f81f8f445..de76e3922eae 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -44,7 +44,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat index 3fa28751404c..def9f0f61519 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat index 047127086ec0..576083d0b4a1 100644 --- a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat index 5bd842760e52..2e2cbbf9d24d 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat index e33c094b8c73..7d2f4032601a 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat index 01423db4a7fe..296524f09413 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat index d22b293c100c..9d935c4a2f7b 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat index 95ca14cca652..b9e5f13d64ad 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat index 723ff2482d5d..2c3c564b3f87 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat index 910b33ea53ee..7c0a0b0f7671 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -47,7 +47,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat index 277b405f6311..157ee8524def 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat index 35a049a0b4e7..7a92f3aa73d5 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat index 305bd606e2a6..a78ce9b36c32 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -47,7 +47,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat index c2d64d2259f0..2a6ddce7fded 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat index 1e42741274cd..4aa538949a1e 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat index 86152131d99f..3042d02ecfd3 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat index 893b7e95a14d..4e326d654b93 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat index 983b4b5c7bdf..48473454ff6e 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat index 1bf7156fd8d1..10a3a1e3c618 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -46,7 +46,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat index 289efd917dfc..0f709e9c767b 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat index 7f5b9353d0e4..2733c4659a82 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat index 9310565e313a..286472a7a9d1 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -47,7 +47,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat index c19be07150c3..f32090383fcc 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat index bd55870347ec..0e656e5956ad 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat index 445e07041b88..4f4497a37786 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -47,7 +47,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat index 19ce84fbe3b2..9a67d2758596 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat index bba68af4d9c2..6414dabb04b2 100644 --- a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat +++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat @@ -22,7 +22,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/memory-copy-epochs.wat b/tests/disas/memory-copy-epochs.wat index 8f1d7df65e05..3b7f3e73307a 100644 --- a/tests/disas/memory-copy-epochs.wat +++ b/tests/disas/memory-copy-epochs.wat @@ -12,7 +12,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 24 "VMContext+0x18" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/memory-copy-fuel.wat b/tests/disas/memory-copy-fuel.wat index 69861845ea35..cd18b78337d0 100644 --- a/tests/disas/memory-copy-fuel.wat +++ b/tests/disas/memory-copy-fuel.wat @@ -11,7 +11,7 @@ ;; function u0:0(i64 vmctx, i64, i32, i32, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/memory-copy-inline.wat b/tests/disas/memory-copy-inline.wat index ba9c79e08078..e32429e25f95 100644 --- a/tests/disas/memory-copy-inline.wat +++ b/tests/disas/memory-copy-inline.wat @@ -15,7 +15,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/memory-min-max-same.wat b/tests/disas/memory-min-max-same.wat index 0c098fe7b6ab..bf407286ddc7 100644 --- a/tests/disas/memory-min-max-same.wat +++ b/tests/disas/memory-min-max-same.wat @@ -39,7 +39,7 @@ ;; region2 = 80 "VMContext+0x50" ;; region3 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,26 +49,26 @@ ;; ;; block0(v0: i64, v1: i64, v2: i32): ;; @0028 v3 = iconst.i32 0 -;; @0030 v7 = load.i64 notrap aligned readonly can_move region2 v0+80 -;; @0030 v6 = load.i64 notrap aligned readonly can_move region1 v0+96 -;; @0039 v13 = iconst.i64 0x0001_0000 -;; @0039 v17 = iconst.i64 0 -;; @0039 v15 = load.i64 notrap aligned readonly can_move v0+56 -;; @003e v19 = iconst.i32 1 +;; @0030 v6 = load.i64 notrap aligned readonly can_move region2 v0+80 +;; @0030 v5 = load.i64 notrap aligned readonly can_move region1 v0+96 +;; @0039 v12 = iconst.i64 0x0001_0000 +;; @0039 v16 = iconst.i64 0 +;; @0039 v14 = load.i64 notrap aligned readonly can_move v0+56 +;; @003e v18 = iconst.i32 1 ;; @002e jump block2(v3) ; v3 = 0 ;; -;; block2(v9: i32): -;; @0030 call_indirect.i64 sig0, v7(v6, v0) -;; v22 = iconst.i32 0 -;; @0036 v10 = iadd.i32 v2, v9 -;; @0039 v12 = uextend.i64 v10 -;; v23 = iconst.i64 0x0001_0000 -;; v24 = icmp ugt v12, v23 ; v23 = 0x0001_0000 -;; @0039 v16 = iadd.i64 v15, v12 -;; v25 = iconst.i64 0 -;; v26 = select_spectre_guard v24, v25, v16 ; v25 = 0 -;; @0039 store little region3 v22, v26 ; v22 = 0 -;; v27 = iconst.i32 1 -;; v28 = iadd v9, v27 ; v27 = 1 -;; @0043 jump block2(v28) +;; block2(v8: i32): +;; @0030 call_indirect.i64 sig0, v6(v5, v0) +;; v21 = iconst.i32 0 +;; @0036 v9 = iadd.i32 v2, v8 +;; @0039 v11 = uextend.i64 v9 +;; v22 = iconst.i64 0x0001_0000 +;; v23 = icmp ugt v11, v22 ; v22 = 0x0001_0000 +;; @0039 v15 = iadd.i64 v14, v11 +;; v24 = iconst.i64 0 +;; v25 = select_spectre_guard v23, v24, v15 ; v24 = 0 +;; @0039 store little region3 v21, v25 ; v21 = 0 +;; v26 = iconst.i32 1 +;; v27 = iadd v8, v26 ; v26 = 1 +;; @0043 jump block2(v27) ;; } diff --git a/tests/disas/memory.wat b/tests/disas/memory.wat index c2575a4d3031..68ba0ac32bd0 100644 --- a/tests/disas/memory.wat +++ b/tests/disas/memory.wat @@ -16,7 +16,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/memory_copy_host64.wat b/tests/disas/memory_copy_host64.wat index 3a929493af88..88c24d60f933 100644 --- a/tests/disas/memory_copy_host64.wat +++ b/tests/disas/memory_copy_host64.wat @@ -52,7 +52,7 @@ ;; function u0:0(i64 vmctx, i64, i32, i32, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+88 @@ -85,7 +85,7 @@ ;; function u0:1(i64 vmctx, i64, i32, i32, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+88 @@ -122,7 +122,7 @@ ;; function u0:2(i64 vmctx, i64, i64, i32, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+88 @@ -158,7 +158,7 @@ ;; function u0:3(i64 vmctx, i64, i64, i64, i64) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+120 @@ -188,7 +188,7 @@ ;; function u0:4(i64 vmctx, i64, i64, i64, i64) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+120 @@ -222,7 +222,7 @@ ;; function u0:5(i64 vmctx, i64, i32, i64, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+120 diff --git a/tests/disas/memory_fill_host64.wat b/tests/disas/memory_fill_host64.wat index 036e5b06b505..2a84d4f82cca 100644 --- a/tests/disas/memory_fill_host64.wat +++ b/tests/disas/memory_fill_host64.wat @@ -46,7 +46,7 @@ ;; function u0:0(i64 vmctx, i64, i32, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+96 @@ -75,7 +75,7 @@ ;; function u0:1(i64 vmctx, i64, i64, i64) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+112 @@ -102,7 +102,7 @@ ;; function u0:2(i64 vmctx, i64, i32, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+128 @@ -131,7 +131,7 @@ ;; function u0:3(i64 vmctx, i64, i64, i64) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+144 @@ -158,7 +158,7 @@ ;; function u0:4(i64 vmctx, i64, i32, i32) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+160 diff --git a/tests/disas/metadata-for-internal-asserts.wat b/tests/disas/metadata-for-internal-asserts.wat index 755c688f711b..f75dba39e0eb 100644 --- a/tests/disas/metadata-for-internal-asserts.wat +++ b/tests/disas/metadata-for-internal-asserts.wat @@ -20,8 +20,8 @@ ;; movl (%rsi), %eax ;; cmpl $0x65726f63, %eax ;; jne 0x70 -;; 22: movq 8(%rsi), %rax -;; movq %rbp, %rcx +;; 22: movq %rbp, %rcx +;; movq 8(%rsi), %rax ;; movq %rcx, 0x30(%rax) ;; movq %rbp, %rcx ;; movq 8(%rcx), %rcx diff --git a/tests/disas/multi-0.wat b/tests/disas/multi-0.wat index 0c4784bf7d19..9c712bca66bf 100644 --- a/tests/disas/multi-0.wat +++ b/tests/disas/multi-0.wat @@ -7,7 +7,7 @@ ;; function u0:0(i64 vmctx, i64, i64) -> i64, i64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-1.wat b/tests/disas/multi-1.wat index 9ceef5312051..c15b4d5426d9 100644 --- a/tests/disas/multi-1.wat +++ b/tests/disas/multi-1.wat @@ -10,7 +10,7 @@ ;; function u0:0(i64 vmctx, i64, i64, i32) -> i32, i64, f64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-10.wat b/tests/disas/multi-10.wat index be9ef471fa7c..460cb53a0b4b 100644 --- a/tests/disas/multi-10.wat +++ b/tests/disas/multi-10.wat @@ -14,7 +14,7 @@ ;; function u0:0(i64 vmctx, i64, i64, i32) -> i64, i64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-11.wat b/tests/disas/multi-11.wat index e5adbf6d17a3..7c1dbbfeb144 100644 --- a/tests/disas/multi-11.wat +++ b/tests/disas/multi-11.wat @@ -11,7 +11,7 @@ ;; function u0:0(i64 vmctx, i64, i64) -> i64, i64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-12.wat b/tests/disas/multi-12.wat index 36f19830bcec..c0a82ca25ccd 100644 --- a/tests/disas/multi-12.wat +++ b/tests/disas/multi-12.wat @@ -13,7 +13,7 @@ ;; function u0:0(i64 vmctx, i64, i64, i64, i64) -> i64, i64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-13.wat b/tests/disas/multi-13.wat index 25ee5b7ae3a2..8678a5224b40 100644 --- a/tests/disas/multi-13.wat +++ b/tests/disas/multi-13.wat @@ -14,7 +14,7 @@ ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-14.wat b/tests/disas/multi-14.wat index 3039c39e2ac0..28c56dd8e3c9 100644 --- a/tests/disas/multi-14.wat +++ b/tests/disas/multi-14.wat @@ -14,7 +14,7 @@ ;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-15.wat b/tests/disas/multi-15.wat index 24599def4cd3..b2ced2c121db 100644 --- a/tests/disas/multi-15.wat +++ b/tests/disas/multi-15.wat @@ -26,7 +26,7 @@ ;; function u0:0(i64 vmctx, i64, i32, i64, f32, f32, i32, f64, f32, i32, i32, i32, f32, f64, f64, f64, i32, i32, f32) -> f64, f32, i32, i32, i32, i64, f32, i32, i32, f32, f64, f64, i32, f32, i32, f64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-16.wat b/tests/disas/multi-16.wat index 1dfbfcfde4cb..5bc4d1331ef4 100644 --- a/tests/disas/multi-16.wat +++ b/tests/disas/multi-16.wat @@ -13,7 +13,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-17.wat b/tests/disas/multi-17.wat index 85f0956f1abb..01ad6d20b088 100644 --- a/tests/disas/multi-17.wat +++ b/tests/disas/multi-17.wat @@ -30,7 +30,7 @@ ;; function u0:0(i64 vmctx, i64, i32, i32, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i64, i32, i32, i32) -> i32 tail ;; fn0 = colocated u0:0 sig0 diff --git a/tests/disas/multi-2.wat b/tests/disas/multi-2.wat index 8eda7f0ff1f5..d9609da1b56d 100644 --- a/tests/disas/multi-2.wat +++ b/tests/disas/multi-2.wat @@ -10,7 +10,7 @@ ;; function u0:0(i64 vmctx, i64, i64, i64) -> i64, i64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-3.wat b/tests/disas/multi-3.wat index 0733c6aeab0e..293231a575fe 100644 --- a/tests/disas/multi-3.wat +++ b/tests/disas/multi-3.wat @@ -17,7 +17,7 @@ ;; function u0:0(i64 vmctx, i64, i32, i64, i64) -> i64, i64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-4.wat b/tests/disas/multi-4.wat index 8b5443c0ef94..dd0efb8ca822 100644 --- a/tests/disas/multi-4.wat +++ b/tests/disas/multi-4.wat @@ -17,7 +17,7 @@ ;; function u0:0(i64 vmctx, i64, i32, i64, i64) -> i64, i64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-5.wat b/tests/disas/multi-5.wat index d2a06931e26b..9be165187ef7 100644 --- a/tests/disas/multi-5.wat +++ b/tests/disas/multi-5.wat @@ -15,7 +15,7 @@ ;; function u0:0(i64 vmctx, i64) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-6.wat b/tests/disas/multi-6.wat index c349d2abfdf4..40111d5e4fb2 100644 --- a/tests/disas/multi-6.wat +++ b/tests/disas/multi-6.wat @@ -15,7 +15,7 @@ ;; function u0:0(i64 vmctx, i64) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-7.wat b/tests/disas/multi-7.wat index 26a7bb66c964..1d3687abb2fd 100644 --- a/tests/disas/multi-7.wat +++ b/tests/disas/multi-7.wat @@ -13,7 +13,7 @@ ;; function u0:0(i64 vmctx, i64, i64, i32) -> i64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-8.wat b/tests/disas/multi-8.wat index 7e42996fa352..0f9216125db9 100644 --- a/tests/disas/multi-8.wat +++ b/tests/disas/multi-8.wat @@ -16,7 +16,7 @@ ;; function u0:0(i64 vmctx, i64, i64, i32) -> i64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/multi-9.wat b/tests/disas/multi-9.wat index 69407ca4cae8..fd71e874e403 100644 --- a/tests/disas/multi-9.wat +++ b/tests/disas/multi-9.wat @@ -19,7 +19,7 @@ ;; function u0:0(i64 vmctx, i64, i64, i32) -> i64 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/non-fixed-size-memory.wat b/tests/disas/non-fixed-size-memory.wat index 71515b32ac5f..d3105042f15f 100644 --- a/tests/disas/non-fixed-size-memory.wat +++ b/tests/disas/non-fixed-size-memory.wat @@ -24,7 +24,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -49,7 +49,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/nullref.wat b/tests/disas/nullref.wat index b4191cd60f81..8ca382d2b169 100644 --- a/tests/disas/nullref.wat +++ b/tests/disas/nullref.wat @@ -15,7 +15,7 @@ ;; function u0:0(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -30,7 +30,7 @@ ;; function u0:1(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/passive-data.wat b/tests/disas/passive-data.wat index 3c10fc2f32e3..3130819d5d20 100644 --- a/tests/disas/passive-data.wat +++ b/tests/disas/passive-data.wat @@ -18,7 +18,7 @@ ;; region1 = 152 "VMContext+0x98" ;; region2 = 144 "VMContext+0x90" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -65,7 +65,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 152 "VMContext+0x98" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/pic.wat b/tests/disas/pic.wat index 3e4b80eb52ee..eeaeb82fa482 100644 --- a/tests/disas/pic.wat +++ b/tests/disas/pic.wat @@ -51,7 +51,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -76,7 +76,7 @@ ;; region3 = 96 "VMContext+0x60" ;; region4 = 80 "VMContext+0x50" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -98,14 +98,14 @@ ;; @0078 v17 = iconst.i64 12 ;; @0078 v18 = iadd v16, v17 ; v17 = 12 ;; @0078 store little region2 v13, v18 -;; @0084 v24 = load.i64 notrap aligned readonly can_move region4 v0+80 -;; @0084 v23 = load.i64 notrap aligned readonly can_move region3 v0+96 -;; v36 = iconst.i32 -4 -;; v37 = iadd v6, v36 ; v36 = -4 -;; @0084 call_indirect sig0, v24(v23, v0, v37) -;; v44 = iconst.i64 0x0010_0000 -;; @0090 v29 = iadd v11, v44 ; v44 = 0x0010_0000 -;; @0090 store little region2 v13, v29 +;; @0084 v23 = load.i64 notrap aligned readonly can_move region4 v0+80 +;; @0084 v22 = load.i64 notrap aligned readonly can_move region3 v0+96 +;; v35 = iconst.i32 -4 +;; v36 = iadd v6, v35 ; v35 = -4 +;; @0084 call_indirect sig0, v23(v22, v0, v36) +;; v43 = iconst.i64 0x0010_0000 +;; @0090 v28 = iadd v11, v43 ; v43 = 0x0010_0000 +;; @0090 store little region2 v13, v28 ;; @0098 store notrap aligned region1 v6, v0+128 ;; @009c jump block1 ;; diff --git a/tests/disas/pr2303.wat b/tests/disas/pr2303.wat index f61e8b3985c6..1f3ccff06119 100644 --- a/tests/disas/pr2303.wat +++ b/tests/disas/pr2303.wat @@ -20,7 +20,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 536870912 "PublicMemory" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/pr2559.wat b/tests/disas/pr2559.wat index 123e81b78c55..c4c0ff5f619b 100644 --- a/tests/disas/pr2559.wat +++ b/tests/disas/pr2559.wat @@ -55,7 +55,7 @@ ;; function u0:0(i64 vmctx, i64) -> i8x16, i8x16, i8x16 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i64) -> i8x16, i8x16, i8x16 tail ;; fn0 = colocated u0:0 sig0 @@ -96,7 +96,7 @@ ;; function u0:1(i64 vmctx, i64) -> i8x16, i8x16, i8x16 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i64) -> i8x16, i8x16, i8x16 tail ;; fn0 = colocated u0:1 sig0 diff --git a/tests/disas/pulley-entry-trampoline.wat b/tests/disas/pulley-entry-trampoline.wat index 1b87bbb44b6f..891981b48ec9 100644 --- a/tests/disas/pulley-entry-trampoline.wat +++ b/tests/disas/pulley-entry-trampoline.wat @@ -6,8 +6,8 @@ ;; wasm[0]::array_to_wasm_trampoline[0]: ;; push_frame_save 128, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, sp, spilltmp0 -;; xload64le_o32 x11, x0, 8 ;; xmov_fp x12 +;; xload64le_o32 x11, x0, 8 ;; xstore64le_o32 x11, 72, x12 ;; xmov x12, sp ;; xstore64le_o32 x11, 64, x12 diff --git a/tests/disas/readonly-funcrefs.wat b/tests/disas/readonly-funcrefs.wat index 9febf947e3b1..e3006af47a56 100644 --- a/tests/disas/readonly-funcrefs.wat +++ b/tests/disas/readonly-funcrefs.wat @@ -21,7 +21,7 @@ ;; function u0:0(i64 vmctx, i64) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -37,7 +37,7 @@ ;; region1 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; region2 = 40 "VMContext+0x28" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+48 diff --git a/tests/disas/readonly-heap-base-pointer1.wat b/tests/disas/readonly-heap-base-pointer1.wat index 4b1c105079b3..e2285d96acae 100644 --- a/tests/disas/readonly-heap-base-pointer1.wat +++ b/tests/disas/readonly-heap-base-pointer1.wat @@ -11,7 +11,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/readonly-heap-base-pointer2.wat b/tests/disas/readonly-heap-base-pointer2.wat index b9096e41606f..86d776cb9278 100644 --- a/tests/disas/readonly-heap-base-pointer2.wat +++ b/tests/disas/readonly-heap-base-pointer2.wat @@ -12,7 +12,7 @@ ;; region1 = 48 "VMContext+0x30" ;; region2 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region1 gv3+48 diff --git a/tests/disas/readonly-heap-base-pointer3.wat b/tests/disas/readonly-heap-base-pointer3.wat index adba2dfc1e04..30e7ead80fe4 100644 --- a/tests/disas/readonly-heap-base-pointer3.wat +++ b/tests/disas/readonly-heap-base-pointer3.wat @@ -11,7 +11,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/ref-func-0.wat b/tests/disas/ref-func-0.wat index 4e3668fa812f..a16c054614f3 100644 --- a/tests/disas/ref-func-0.wat +++ b/tests/disas/ref-func-0.wat @@ -17,7 +17,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1610612736 "PublicGlobal" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; stack_limit = gv2 diff --git a/tests/disas/riscv64-component-builtins.wat b/tests/disas/riscv64-component-builtins.wat index 2108eff72d4d..6f1c6a17e7b9 100644 --- a/tests/disas/riscv64-component-builtins.wat +++ b/tests/disas/riscv64-component-builtins.wat @@ -35,8 +35,8 @@ ;; brif v15, block2, block1 ;; ;; block1 cold: -;; v16 = load.i64 notrap aligned readonly region1 v1+16 -;; v17 = load.i64 notrap aligned readonly v16+328 +;; v16 = load.i64 notrap aligned readonly can_move region1 v1+16 +;; v17 = load.i64 notrap aligned readonly can_move v16+328 ;; call_indirect sig1, v17(v1) ;; trap user1 ;; diff --git a/tests/disas/riscv64-entry-trampoline.wat b/tests/disas/riscv64-entry-trampoline.wat index e0fb731c4168..dea9c1e05d36 100644 --- a/tests/disas/riscv64-entry-trampoline.wat +++ b/tests/disas/riscv64-entry-trampoline.wat @@ -33,8 +33,8 @@ ;; fsd fs9, 0x18(sp) ;; fsd fs10, 0x10(sp) ;; fsd fs11, 8(sp) -;; ld a2, 8(a0) ;; mv a3, s0 +;; ld a2, 8(a0) ;; sd a3, 0x48(a2) ;; mv a3, sp ;; sd a3, 0x40(a2) diff --git a/tests/disas/s390x-entry-trampoline.wat b/tests/disas/s390x-entry-trampoline.wat index 512757e5dc8e..17dd61f3a05b 100644 --- a/tests/disas/s390x-entry-trampoline.wat +++ b/tests/disas/s390x-entry-trampoline.wat @@ -17,8 +17,8 @@ ;; std %f13, 0xc8(%r15) ;; std %f14, 0xd0(%r15) ;; std %f15, 0xd8(%r15) -;; lg %r4, 8(%r2) ;; lg %r5, 0(%r15) +;; lg %r4, 8(%r2) ;; stg %r5, 0x48(%r4) ;; lgr %r5, %r15 ;; stg %r5, 0x40(%r4) diff --git a/tests/disas/select.wat b/tests/disas/select.wat index d202a7de0ec8..4852f10ccd7f 100644 --- a/tests/disas/select.wat +++ b/tests/disas/select.wat @@ -23,7 +23,7 @@ ;; function u0:0(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -41,7 +41,7 @@ ;; function u0:1(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -59,7 +59,7 @@ ;; function u0:2(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/simd-store.wat b/tests/disas/simd-store.wat index c17ecc811c76..76bc6dd694ef 100644 --- a/tests/disas/simd-store.wat +++ b/tests/disas/simd-store.wat @@ -88,7 +88,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -112,7 +112,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -138,7 +138,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -164,7 +164,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -188,7 +188,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -214,7 +214,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -240,7 +240,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -264,7 +264,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -290,7 +290,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -316,7 +316,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -342,7 +342,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -366,7 +366,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -392,7 +392,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -418,7 +418,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -444,7 +444,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -470,7 +470,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -496,7 +496,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -522,7 +522,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -548,7 +548,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -574,7 +574,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -600,7 +600,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -626,7 +626,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -652,7 +652,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -678,7 +678,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -704,7 +704,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -730,7 +730,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -756,7 +756,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -782,7 +782,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -808,7 +808,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -832,7 +832,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -858,7 +858,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -884,7 +884,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -910,7 +910,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 @@ -934,7 +934,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 805306368 "DefinedMemory(StaticModuleIndex(0), DefinedMemoryIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+64 diff --git a/tests/disas/simd.wat b/tests/disas/simd.wat index bd54952a3755..78b7e64e8430 100644 --- a/tests/disas/simd.wat +++ b/tests/disas/simd.wat @@ -33,7 +33,7 @@ ;; function u0:0(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -50,7 +50,7 @@ ;; function u0:1(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; const0 = 0x00000000000000000000000000000000 ;; stack_limit = gv2 @@ -70,7 +70,7 @@ ;; function u0:2(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; const0 = 0x00000004000000030000000200000001 ;; stack_limit = gv2 @@ -88,7 +88,7 @@ ;; function u0:3(i64 vmctx, i64) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; const0 = 0x00000000000000000000000000000000 ;; stack_limit = gv2 diff --git a/tests/disas/simple.wat b/tests/disas/simple.wat index f71004d3e4a4..08ddd4e32fd0 100644 --- a/tests/disas/simple.wat +++ b/tests/disas/simple.wat @@ -21,7 +21,7 @@ ;; function u0:0(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -37,7 +37,7 @@ ;; function u0:1(i64 vmctx, i64, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -50,7 +50,7 @@ ;; function u0:2(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/stack-switching/resume-suspend-data-passing.wat b/tests/disas/stack-switching/resume-suspend-data-passing.wat index 46ed9f59592b..d7df2b66a702 100644 --- a/tests/disas/stack-switching/resume-suspend-data-passing.wat +++ b/tests/disas/stack-switching/resume-suspend-data-passing.wat @@ -41,12 +41,13 @@ ;; ss0 = explicit_slot 16, align = 65536 ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64): ;; @003c v3 = iconst.i32 10 +;; @0044 v7 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; @0044 v31 = iconst.i64 120 ;; @0044 v34 = stack_addr.i64 ss0 ;; @0044 v40 = iconst.i64 16 @@ -57,7 +58,6 @@ ;; @0040 jump block2(v3) ; v3 = 10 ;; ;; block2(v4: i32): -;; @0044 v7 = load.i64 notrap aligned region0 v0+8 ;; @0044 v8 = load.i64 notrap aligned v7+88 ;; @0044 v9 = load.i64 notrap aligned v7+96 ;; @0044 v12 = iconst.i64 1 @@ -148,7 +148,7 @@ ;; ss0 = explicit_slot 8, align = 256 ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i32) -> i64 tail ;; sig1 = (i64 vmctx, i64, i32, i32) -> i64 tail @@ -168,6 +168,7 @@ ;; @0058 v8 = uextend.i128 v6 ;; @0058 v13 = bor v117, v8 ;; @0062 v24 = iconst.i64 1 +;; @0062 v27 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; @0062 v30 = iconst.i64 0 ;; @0062 v31 = iconst.i64 2 ;; @0062 v35 = iconst.i32 1 @@ -199,17 +200,15 @@ ;; v127 = iadd v22, v126 ; v126 = 1 ;; @0062 store notrap aligned v127, v17+72 ;; @0062 v26 = load.i64 notrap aligned v17+64 -;; @0062 v27 = load.i64 notrap aligned region0 v0+8 ;; @0062 v28 = load.i64 notrap aligned v27+88 ;; @0062 v29 = load.i64 notrap aligned v27+96 ;; @0062 store notrap aligned v28, v26+48 ;; @0062 store notrap aligned v29, v26+56 ;; v128 = iconst.i64 0 ;; @0062 store notrap aligned v128, v17+64 ; v128 = 0 -;; @0062 v32 = load.i64 notrap aligned region0 v0+8 ;; v129 = iconst.i64 2 -;; @0062 store notrap aligned v129, v32+88 ; v129 = 2 -;; @0062 store notrap aligned v17, v32+96 +;; @0062 store notrap aligned v129, v27+88 ; v129 = 2 +;; @0062 store notrap aligned v17, v27+96 ;; v130 = iconst.i32 1 ;; v131 = iconst.i64 16 ;; v132 = iadd v17, v131 ; v131 = 16 @@ -217,15 +216,14 @@ ;; v133 = iconst.i32 2 ;; v134 = iadd v29, v131 ; v131 = 16 ;; @0062 store notrap aligned v133, v134 ; v133 = 2 -;; @0062 v41 = load.i64 notrap aligned readonly region0 v0+8 -;; @0062 v44 = load.i64 notrap aligned v41+72 +;; @0062 v44 = load.i64 notrap aligned v27+72 ;; @0062 store notrap aligned v44, v29+8 -;; @0062 v45 = load.i64 notrap aligned v41+24 +;; @0062 v45 = load.i64 notrap aligned v27+24 ;; @0062 store notrap aligned v45, v29 ;; @0062 v48 = load.i64 notrap aligned v17 -;; @0062 store notrap aligned v48, v41+24 +;; @0062 store notrap aligned v48, v27+24 ;; @0062 v49 = load.i64 notrap aligned v17+8 -;; @0062 store notrap aligned v49, v41+72 +;; @0062 store notrap aligned v49, v27+72 ;; v135 = iconst.i64 24 ;; v136 = iadd v29, v135 ; v135 = 24 ;; @0062 store notrap aligned v130, v136+4 ; v130 = 1 @@ -241,11 +239,10 @@ ;; v141 = iadd v64, v140 ; v140 = -24 ;; v142 = iconst.i64 0x0001_0000_0000 ;; @0062 v67 = stack_switch v141, v141, v142 ; v142 = 0x0001_0000_0000 -;; @0062 v68 = load.i64 notrap aligned region0 v0+8 -;; @0062 v69 = load.i64 notrap aligned v68+88 -;; @0062 v70 = load.i64 notrap aligned v68+96 -;; @0062 store notrap aligned v28, v68+88 -;; @0062 store notrap aligned v29, v68+96 +;; @0062 v69 = load.i64 notrap aligned v27+88 +;; @0062 v70 = load.i64 notrap aligned v27+96 +;; @0062 store notrap aligned v28, v27+88 +;; @0062 store notrap aligned v29, v27+96 ;; @0062 store notrap aligned v130, v134 ; v130 = 1 ;; v143 = iconst.i32 0 ;; @0062 store notrap aligned v143, v136 ; v143 = 0 @@ -257,12 +254,12 @@ ;; @0062 brif v145, block7, block6 ;; ;; block7: -;; @0062 v84 = load.i64 notrap aligned v41+72 +;; @0062 v84 = load.i64 notrap aligned v27+72 ;; @0062 store notrap aligned v84, v70+8 ;; @0062 v87 = load.i64 notrap aligned v29 -;; @0062 store notrap aligned v87, v41+24 +;; @0062 store notrap aligned v87, v27+24 ;; @0062 v88 = load.i64 notrap aligned v29+8 -;; @0062 store notrap aligned v88, v41+72 +;; @0062 store notrap aligned v88, v27+72 ;; @0062 v90 = load.i64 notrap aligned v70+72 ;; @0062 jump block8 ;; @@ -284,9 +281,9 @@ ;; ;; block6: ;; @0062 v104 = load.i64 notrap aligned v29 -;; @0062 store notrap aligned v104, v41+24 +;; @0062 store notrap aligned v104, v27+24 ;; @0062 v105 = load.i64 notrap aligned v29+8 -;; @0062 store notrap aligned v105, v41+72 +;; @0062 store notrap aligned v105, v27+72 ;; @0062 v108 = iconst.i32 4 ;; v146 = iconst.i64 16 ;; v147 = iadd.i64 v70, v146 ; v146 = 16 diff --git a/tests/disas/stack-switching/resume-suspend.wat b/tests/disas/stack-switching/resume-suspend.wat index 234514c50f8d..d0a3b84b7a67 100644 --- a/tests/disas/stack-switching/resume-suspend.wat +++ b/tests/disas/stack-switching/resume-suspend.wat @@ -25,12 +25,12 @@ ;; function u0:0(i64 vmctx, i64) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; ;; block0(v0: i64, v1: i64): -;; @003b v4 = load.i64 notrap aligned region0 v0+8 +;; @003b v4 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; @003b v5 = load.i64 notrap aligned v4+88 ;; @003b v6 = load.i64 notrap aligned v4+96 ;; @003b v9 = iconst.i64 1 @@ -109,7 +109,7 @@ ;; ss0 = explicit_slot 8, align = 256 ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i32) -> i64 tail ;; sig1 = (i64 vmctx, i64, i32, i32) -> i64 tail @@ -143,17 +143,16 @@ ;; @004e v30 = iadd v27, v29 ; v29 = 1 ;; @004e store notrap aligned v30, v134+72 ;; @004e v31 = load.i64 notrap aligned v134+64 -;; @004e v32 = load.i64 notrap aligned region0 v0+8 +;; @004e v32 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; @004e v33 = load.i64 notrap aligned v32+88 ;; @004e v34 = load.i64 notrap aligned v32+96 ;; @004e store notrap aligned v33, v31+48 ;; @004e store notrap aligned v34, v31+56 ;; @0040 v2 = iconst.i64 0 ;; @004e store notrap aligned v2, v134+64 ; v2 = 0 -;; @004e v37 = load.i64 notrap aligned region0 v0+8 ;; @004e v36 = iconst.i64 2 -;; @004e store notrap aligned v36, v37+88 ; v36 = 2 -;; @004e store notrap aligned v134, v37+96 +;; @004e store notrap aligned v36, v32+88 ; v36 = 2 +;; @004e store notrap aligned v134, v32+96 ;; @004e v40 = iconst.i32 1 ;; @004e v41 = iconst.i64 16 ;; @004e v42 = iadd v134, v41 ; v41 = 16 @@ -161,15 +160,14 @@ ;; @004e v43 = iconst.i32 2 ;; @004e v45 = iadd v34, v41 ; v41 = 16 ;; @004e store notrap aligned v43, v45 ; v43 = 2 -;; @004e v46 = load.i64 notrap aligned readonly region0 v0+8 -;; @004e v49 = load.i64 notrap aligned v46+72 +;; @004e v49 = load.i64 notrap aligned v32+72 ;; @004e store notrap aligned v49, v34+8 -;; @004e v50 = load.i64 notrap aligned v46+24 +;; @004e v50 = load.i64 notrap aligned v32+24 ;; @004e store notrap aligned v50, v34 ;; @004e v53 = load.i64 notrap aligned v134 -;; @004e store notrap aligned v53, v46+24 +;; @004e store notrap aligned v53, v32+24 ;; @004e v54 = load.i64 notrap aligned v134+8 -;; @004e store notrap aligned v54, v46+72 +;; @004e store notrap aligned v54, v32+72 ;; @004e v55 = iconst.i64 24 ;; @004e v56 = iadd v34, v55 ; v55 = 24 ;; @004e store notrap aligned v40, v56+4 ; v40 = 1 @@ -187,11 +185,10 @@ ;; @004e v71 = iadd v69, v70 ; v70 = -24 ;; v138 = iconst.i64 0x0001_0000_0000 ;; @004e v72 = stack_switch v71, v71, v138 ; v138 = 0x0001_0000_0000 -;; @004e v73 = load.i64 notrap aligned region0 v0+8 -;; @004e v74 = load.i64 notrap aligned v73+88 -;; @004e v75 = load.i64 notrap aligned v73+96 -;; @004e store notrap aligned v33, v73+88 -;; @004e store notrap aligned v34, v73+96 +;; @004e v74 = load.i64 notrap aligned v32+88 +;; @004e v75 = load.i64 notrap aligned v32+96 +;; @004e store notrap aligned v33, v32+88 +;; @004e store notrap aligned v34, v32+96 ;; @004e store notrap aligned v40, v45 ; v40 = 1 ;; v141 = iconst.i32 0 ;; @004e store notrap aligned v141, v56 ; v141 = 0 @@ -203,12 +200,12 @@ ;; @004e brif v84, block5, block4 ;; ;; block5: -;; @004e v89 = load.i64 notrap aligned v46+72 +;; @004e v89 = load.i64 notrap aligned v32+72 ;; @004e store notrap aligned v89, v75+8 ;; @004e v92 = load.i64 notrap aligned v34 -;; @004e store notrap aligned v92, v46+24 +;; @004e store notrap aligned v92, v32+24 ;; @004e v93 = load.i64 notrap aligned v34+8 -;; @004e store notrap aligned v93, v46+72 +;; @004e store notrap aligned v93, v32+72 ;; @004e v95 = load.i64 notrap aligned v75+72 ;; @004e jump block6 ;; @@ -234,9 +231,9 @@ ;; ;; block4: ;; @004e v108 = load.i64 notrap aligned v34 -;; @004e store notrap aligned v108, v46+24 +;; @004e store notrap aligned v108, v32+24 ;; @004e v109 = load.i64 notrap aligned v34+8 -;; @004e store notrap aligned v109, v46+72 +;; @004e store notrap aligned v109, v32+72 ;; @004e v112 = iconst.i32 4 ;; v142 = iconst.i64 16 ;; v143 = iadd.i64 v75, v142 ; v142 = 16 diff --git a/tests/disas/stack-switching/symmetric-switch.wat b/tests/disas/stack-switching/symmetric-switch.wat index d2db2051b509..2769f3138c83 100644 --- a/tests/disas/stack-switching/symmetric-switch.wat +++ b/tests/disas/stack-switching/symmetric-switch.wat @@ -29,7 +29,7 @@ ;; ss0 = explicit_slot 24, align = 256 ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i32) -> i64 tail ;; sig1 = (i64 vmctx, i64, i32, i32) -> i64 tail @@ -65,7 +65,7 @@ ;; @003e store notrap aligned v22, v14+72 ;; @003e v23 = iconst.i64 48 ;; @003e v24 = iadd v0, v23 ; v23 = 48 -;; @003e v25 = load.i64 notrap aligned region0 v0+8 +;; @003e v25 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; @003e v26 = load.i64 notrap aligned v25+88 ;; @003e v27 = load.i64 notrap aligned v25+96 ;; @003e jump block2(v26, v27) @@ -115,7 +115,7 @@ ;; @003e v57 = iconst.i64 0 ;; @003e store notrap aligned v56, v29+48 ; v56 = 0 ;; @003e store notrap aligned v57, v29+56 ; v57 = 0 -;; @003e v58 = load.i64 notrap aligned readonly region0 v0+8 +;; @003e v58 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; @003e v59 = iconst.i64 0 ;; @003e v60 = iadd v52, v59 ; v59 = 0 ;; @003e v61 = load.i64 notrap aligned v58+72 @@ -176,7 +176,7 @@ ;; @003e store.i64 notrap aligned v32, v102+48 ;; @003e store.i64 notrap aligned v33, v102+56 ;; @003e v103 = iconst.i64 2 -;; @003e v104 = load.i64 notrap aligned region0 v0+8 +;; @003e v104 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; @003e store notrap aligned v103, v104+88 ; v103 = 2 ;; @003e store.i64 notrap aligned v14, v104+96 ;; @003e v105 = iconst.i64 0 @@ -230,7 +230,7 @@ ;; function u0:1(i64 vmctx, i64, i128) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -245,7 +245,7 @@ ;; ss0 = explicit_slot 8, align = 256 ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, i32) -> i64 tail ;; sig1 = (i64 vmctx, i64, i32, i32) -> i64 tail @@ -283,7 +283,7 @@ ;; @004b v22 = iadd v19, v21 ; v21 = 1 ;; @004b store notrap aligned v22, v14+72 ;; @004b v23 = load.i64 notrap aligned v14+64 -;; @004b v24 = load.i64 notrap aligned region0 v0+8 +;; @004b v24 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; @004b v25 = load.i64 notrap aligned v24+88 ;; @004b v26 = load.i64 notrap aligned v24+96 ;; @004b store notrap aligned v25, v23+48 @@ -291,7 +291,7 @@ ;; @004b v27 = iconst.i64 0 ;; @004b store notrap aligned v27, v14+64 ; v27 = 0 ;; @004b v28 = iconst.i64 2 -;; @004b v29 = load.i64 notrap aligned region0 v0+8 +;; @004b v29 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; @004b store notrap aligned v28, v29+88 ; v28 = 2 ;; @004b store notrap aligned v14, v29+96 ;; @004b v30 = iconst.i64 0 @@ -304,7 +304,7 @@ ;; @004b v36 = iconst.i64 16 ;; @004b v37 = iadd v26, v36 ; v36 = 16 ;; @004b store notrap aligned v35, v37 ; v35 = 2 -;; @004b v38 = load.i64 notrap aligned readonly region0 v0+8 +;; @004b v38 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; @004b v39 = iconst.i64 0 ;; @004b v40 = iadd v26, v39 ; v39 = 0 ;; @004b v41 = load.i64 notrap aligned v38+72 @@ -340,10 +340,10 @@ ;; @004b v62 = iconst.i64 -24 ;; @004b v63 = iadd v61, v62 ; v62 = -24 ;; @004b v64 = stack_switch v63, v63, v58 -;; @004b v65 = load.i64 notrap aligned region0 v0+8 +;; @004b v65 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; @004b v66 = load.i64 notrap aligned v65+88 ;; @004b v67 = load.i64 notrap aligned v65+96 -;; @004b v68 = load.i64 notrap aligned region0 v0+8 +;; @004b v68 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; @004b store notrap aligned v25, v68+88 ;; @004b store notrap aligned v26, v68+96 ;; @004b v69 = iconst.i32 1 diff --git a/tests/disas/startup-data-active.wat b/tests/disas/startup-data-active.wat index 2db5ff99cddd..653268bf71e2 100644 --- a/tests/disas/startup-data-active.wat +++ b/tests/disas/startup-data-active.wat @@ -17,8 +17,8 @@ ;; jump block1 ;; ;; block1: -;; v4 = load.i64 notrap aligned region0 v0+8 ;; v5 = get_frame_pointer.i64 +;; v4 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; store notrap aligned v5, v4+72 ;; v6 = get_stack_pointer.i64 ;; store notrap aligned v6, v4+64 diff --git a/tests/disas/startup-elem-active.wat b/tests/disas/startup-elem-active.wat index 0c3158f8c2b1..4e53ea4cc88e 100644 --- a/tests/disas/startup-elem-active.wat +++ b/tests/disas/startup-elem-active.wat @@ -21,8 +21,8 @@ ;; jump block1 ;; ;; block1: -;; v4 = load.i64 notrap aligned region0 v0+8 ;; v5 = get_frame_pointer.i64 +;; v4 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; store notrap aligned v5, v4+72 ;; v6 = get_stack_pointer.i64 ;; store notrap aligned v6, v4+64 diff --git a/tests/disas/startup-global.wat b/tests/disas/startup-global.wat index 23a53b1e01a5..dff51e01d70f 100644 --- a/tests/disas/startup-global.wat +++ b/tests/disas/startup-global.wat @@ -14,8 +14,8 @@ ;; jump block1 ;; ;; block1: -;; v4 = load.i64 notrap aligned region0 v0+8 ;; v5 = get_frame_pointer.i64 +;; v4 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; store notrap aligned v5, v4+72 ;; v6 = get_stack_pointer.i64 ;; store notrap aligned v6, v4+64 diff --git a/tests/disas/startup-passive-segment.wat b/tests/disas/startup-passive-segment.wat index a6d1ccc7e76a..e2bc5ece1e4a 100644 --- a/tests/disas/startup-passive-segment.wat +++ b/tests/disas/startup-passive-segment.wat @@ -15,8 +15,8 @@ ;; jump block1 ;; ;; block1: -;; v4 = load.i64 notrap aligned region0 v0+8 ;; v5 = get_frame_pointer.i64 +;; v4 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; store notrap aligned v5, v4+72 ;; v6 = get_stack_pointer.i64 ;; store notrap aligned v6, v4+64 diff --git a/tests/disas/startup-start.wat b/tests/disas/startup-start.wat index 9d923d6a95a8..2ad5cc375a44 100644 --- a/tests/disas/startup-start.wat +++ b/tests/disas/startup-start.wat @@ -15,8 +15,8 @@ ;; jump block1 ;; ;; block1: -;; v4 = load.i64 notrap aligned region0 v0+8 ;; v5 = get_frame_pointer.i64 +;; v4 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; store notrap aligned v5, v4+72 ;; v6 = get_stack_pointer.i64 ;; store notrap aligned v6, v4+64 diff --git a/tests/disas/startup-table-initial-value.wat b/tests/disas/startup-table-initial-value.wat index 7b39ecc93333..e82a4b8e616f 100644 --- a/tests/disas/startup-table-initial-value.wat +++ b/tests/disas/startup-table-initial-value.wat @@ -15,8 +15,8 @@ ;; jump block1 ;; ;; block1: -;; v4 = load.i64 notrap aligned region0 v0+8 ;; v5 = get_frame_pointer.i64 +;; v4 = load.i64 notrap aligned readonly can_move region0 v0+8 ;; store notrap aligned v5, v4+72 ;; v6 = get_stack_pointer.i64 ;; store notrap aligned v6, v4+64 diff --git a/tests/disas/sub-global.wat b/tests/disas/sub-global.wat index b4fef9d82618..f0f8c6a2d621 100644 --- a/tests/disas/sub-global.wat +++ b/tests/disas/sub-global.wat @@ -16,7 +16,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1879048192 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; stack_limit = gv2 diff --git a/tests/disas/table-copy.wat b/tests/disas/table-copy.wat index 80b088290074..948de25668c9 100644 --- a/tests/disas/table-copy.wat +++ b/tests/disas/table-copy.wat @@ -26,7 +26,7 @@ ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32, i32, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -40,7 +40,7 @@ ;; function u0:1(i64 vmctx, i64, i32, i32, i32, i32, i32, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -54,7 +54,7 @@ ;; function u0:2(i64 vmctx, i64, i32, i32, i32, i32, i32, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -70,7 +70,7 @@ ;; region1 = 48 "VMContext+0x30" ;; region2 = 1073741824 "PublicTable" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move region1 gv3+48 @@ -212,7 +212,7 @@ ;; region1 = 48 "VMContext+0x30" ;; region2 = 1073741824 "PublicTable" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+72 diff --git a/tests/disas/table-get-fixed-size.wat b/tests/disas/table-get-fixed-size.wat index adb9d3ee5b65..7b380a60c023 100644 --- a/tests/disas/table-get-fixed-size.wat +++ b/tests/disas/table-get-fixed-size.wat @@ -19,7 +19,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1073741824 "PublicTable" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+48 @@ -47,7 +47,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1073741824 "PublicTable" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+48 diff --git a/tests/disas/table-get.wat b/tests/disas/table-get.wat index a38aa3d9d15c..187ae166ee42 100644 --- a/tests/disas/table-get.wat +++ b/tests/disas/table-get.wat @@ -18,7 +18,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1073741824 "PublicTable" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+48 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1073741824 "PublicTable" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+48 diff --git a/tests/disas/table-set-fixed-size.wat b/tests/disas/table-set-fixed-size.wat index a2c4eb8b4599..5e86975a821e 100644 --- a/tests/disas/table-set-fixed-size.wat +++ b/tests/disas/table-set-fixed-size.wat @@ -20,7 +20,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1073741824 "PublicTable" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+48 @@ -48,7 +48,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1073741824 "PublicTable" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+48 diff --git a/tests/disas/table-set.wat b/tests/disas/table-set.wat index 80aab57a0a0a..4916fb76ac39 100644 --- a/tests/disas/table-set.wat +++ b/tests/disas/table-set.wat @@ -20,7 +20,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1073741824 "PublicTable" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+48 @@ -50,7 +50,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1073741824 "PublicTable" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned gv3+48 diff --git a/tests/disas/typed-funcrefs-eager-init.wat b/tests/disas/typed-funcrefs-eager-init.wat index 0b281235138e..546b4b715f83 100644 --- a/tests/disas/typed-funcrefs-eager-init.wat +++ b/tests/disas/typed-funcrefs-eager-init.wat @@ -116,7 +116,7 @@ ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -131,7 +131,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+48 @@ -163,7 +163,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+48 @@ -196,7 +196,7 @@ ;; region1 = 1879048192 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))" ;; region2 = 1879048193 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(1))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; sig0 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail diff --git a/tests/disas/typed-funcrefs.wat b/tests/disas/typed-funcrefs.wat index 63d46565ae87..ca4eb0a67757 100644 --- a/tests/disas/typed-funcrefs.wat +++ b/tests/disas/typed-funcrefs.wat @@ -116,7 +116,7 @@ ;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -131,7 +131,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+48 @@ -187,7 +187,7 @@ ;; region0 = 8 "VMContext+0x8" ;; region1 = 1342177280 "DefinedTable(StaticModuleIndex(0), DefinedTableIndex(0))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; gv4 = load.i64 notrap aligned readonly can_move gv3+48 @@ -244,7 +244,7 @@ ;; region1 = 1879048192 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(0))" ;; region2 = 1879048193 "DefinedGlobal(StaticModuleIndex(0), DefinedGlobalIndex(1))" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; gv3 = vmctx ;; sig0 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail diff --git a/tests/disas/unreachable_code.wat b/tests/disas/unreachable_code.wat index a38cc69056a9..2f81439ce615 100644 --- a/tests/disas/unreachable_code.wat +++ b/tests/disas/unreachable_code.wat @@ -81,7 +81,7 @@ ;; function u0:0(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -92,7 +92,7 @@ ;; function u0:1(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -106,7 +106,7 @@ ;; function u0:2(i64 vmctx, i64) -> i32 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; @@ -139,7 +139,7 @@ ;; function u0:3(i64 vmctx, i64) tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; stack_limit = gv2 ;; diff --git a/tests/disas/winch/x64/load/grow_load.wat b/tests/disas/winch/x64/load/grow_load.wat index 1a20b87706e7..a11c2c6db31a 100644 --- a/tests/disas/winch/x64/load/grow_load.wat +++ b/tests/disas/winch/x64/load/grow_load.wat @@ -65,7 +65,7 @@ ;; movq %r14, %rdi ;; movl 0xc(%rsp), %esi ;; movl $0, %edx -;; callq 0x2e9 +;; callq 0x2ec ;; addq $0xc, %rsp ;; addq $4, %rsp ;; movq 0x58(%rsp), %r14 diff --git a/tests/disas/winch/x64/table/init_copy_drop.wat b/tests/disas/winch/x64/table/init_copy_drop.wat index 2856d6156505..ab1e576d67e7 100644 --- a/tests/disas/winch/x64/table/init_copy_drop.wat +++ b/tests/disas/winch/x64/table/init_copy_drop.wat @@ -305,7 +305,7 @@ ;; movq %r14, %rdi ;; movl $0, %esi ;; movq 8(%rsp), %rdx -;; callq 0x1188 +;; callq 0x1184 ;; addq $8, %rsp ;; addq $8, %rsp ;; movq 0x28(%rsp), %r14 @@ -390,7 +390,7 @@ ;; movq %r14, %rdi ;; movl $0, %esi ;; movq 8(%rsp), %rdx -;; callq 0x1188 +;; callq 0x1184 ;; addq $8, %rsp ;; addq $8, %rsp ;; movq 0x28(%rsp), %r14 @@ -475,7 +475,7 @@ ;; movq %r14, %rdi ;; movl $0, %esi ;; movq 8(%rsp), %rdx -;; callq 0x1188 +;; callq 0x1184 ;; addq $8, %rsp ;; addq $8, %rsp ;; movq 0x28(%rsp), %r14 @@ -560,7 +560,7 @@ ;; movq %r14, %rdi ;; movl $0, %esi ;; movq 8(%rsp), %rdx -;; callq 0x1188 +;; callq 0x1184 ;; addq $8, %rsp ;; addq $8, %rsp ;; movq 0x28(%rsp), %r14 @@ -645,7 +645,7 @@ ;; movq %r14, %rdi ;; movl $0, %esi ;; movq 8(%rsp), %rdx -;; callq 0x1188 +;; callq 0x1184 ;; addq $8, %rsp ;; addq $8, %rsp ;; movq 0x28(%rsp), %r14 @@ -756,7 +756,7 @@ ;; movq %r14, %rdi ;; movl $0, %esi ;; movl 0xc(%rsp), %edx -;; callq 0x1188 +;; callq 0x1184 ;; addq $0xc, %rsp ;; addq $4, %rsp ;; movq 0x18(%rsp), %r14 diff --git a/tests/disas/x64-entry-trampoline.wat b/tests/disas/x64-entry-trampoline.wat index be475c03a484..eebc2bd415b4 100644 --- a/tests/disas/x64-entry-trampoline.wat +++ b/tests/disas/x64-entry-trampoline.wat @@ -13,8 +13,8 @@ ;; movq %r13, 0x10(%rsp) ;; movq %r14, 0x18(%rsp) ;; movq %r15, 0x20(%rsp) -;; movq 8(%rdi), %rax ;; movq %rbp, %rcx +;; movq 8(%rdi), %rax ;; movq %rcx, 0x48(%rax) ;; movq %rsp, %rcx ;; movq %rcx, 0x40(%rax) diff --git a/tests/disas/x64-simd-round-without-sse41.wat b/tests/disas/x64-simd-round-without-sse41.wat index 9a996bd19962..16e5ecaea950 100644 --- a/tests/disas/x64-simd-round-without-sse41.wat +++ b/tests/disas/x64-simd-round-without-sse41.wat @@ -14,7 +14,7 @@ ;; function u0:0(i64 vmctx, i64, i8x16) -> i8x16 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, f32) -> f32 tail ;; fn0 = colocated u805306368:28 sig0 @@ -46,7 +46,7 @@ ;; function u0:1(i64 vmctx, i64, i8x16) -> i8x16 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, f32) -> f32 tail ;; fn0 = colocated u805306368:30 sig0 @@ -78,7 +78,7 @@ ;; function u0:2(i64 vmctx, i64, i8x16) -> i8x16 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, f32) -> f32 tail ;; fn0 = colocated u805306368:32 sig0 @@ -110,7 +110,7 @@ ;; function u0:3(i64 vmctx, i64, i8x16) -> i8x16 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, f32) -> f32 tail ;; fn0 = colocated u805306368:34 sig0 @@ -142,7 +142,7 @@ ;; function u0:4(i64 vmctx, i64, i8x16) -> i8x16 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, f64) -> f64 tail ;; fn0 = colocated u805306368:29 sig0 @@ -168,7 +168,7 @@ ;; function u0:5(i64 vmctx, i64, i8x16) -> i8x16 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, f64) -> f64 tail ;; fn0 = colocated u805306368:31 sig0 @@ -194,7 +194,7 @@ ;; function u0:6(i64 vmctx, i64, i8x16) -> i8x16 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, f64) -> f64 tail ;; fn0 = colocated u805306368:33 sig0 @@ -220,7 +220,7 @@ ;; function u0:7(i64 vmctx, i64, i8x16) -> i8x16 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; sig0 = (i64 vmctx, f64) -> f64 tail ;; fn0 = colocated u805306368:35 sig0 @@ -246,7 +246,7 @@ ;; function u0:8(i64 vmctx, i64, i8x16) -> i8x16 tail { ;; region0 = 8 "VMContext+0x8" ;; gv0 = vmctx -;; gv1 = load.i64 notrap aligned readonly region0 gv0+8 +;; gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8 ;; gv2 = load.i64 notrap aligned gv1+24 ;; const0 = 0x00000000000000000000000000000000 ;; stack_limit = gv2