A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Make clearing and restoring the `may_leave` flag more amenable to optimization (#13713)
Nick Fitzgerald744ae1317102
diff --git a/crates/cranelift/src/alias_region.rs b/crates/cranelift/src/alias_region.rsindex a7653858a7..2aee704cf6 100644--- a/crates/cranelift/src/alias_region.rs+++ b/crates/cranelift/src/alias_region.rs@@ -1631,8 +1631,8 @@ impl AliasRegions<VMComponentOffsets<u8>> {)}- /// Load a component instance's flags from the `VMComponentContext`.- pub fn vmcomponent_instance_flags(+ /// Load a component instance's `may_leave` flag from the `VMComponentContext`.+ pub fn vmcomponent_instance_may_leave(&mut self,cursor: &mut FuncCursor<'_>,vmctx: ir::Value,@@ -1643,7 +1643,7 @@ impl AliasRegions<VMComponentOffsets<u8>> {ir::types::I32,ir::MemFlagsData::trusted(),vmctx,- self.offsets.instance_flags(instance),+ self.offsets.may_leave(instance),)}}diff --git a/crates/cranelift/src/compiler/component.rs b/crates/cranelift/src/compiler/component.rsindex a0a6836e7a..74d7062943 100644--- a/crates/cranelift/src/compiler/component.rs+++ b/crates/cranelift/src/compiler/component.rs@@ -1113,9 +1113,8 @@ impl<'a> TrampolineCompiler<'a> {// run_destructor_block:// ;; test may_leave, but only if the component instances// ;; differ- // flags = load.i32 vmctx+$instance_flags_offset- // masked = band flags, $FLAG_MAY_LEAVE- // trapz masked, $TRAP_CANNOT_LEAVE_COMPONENT+ // may_leave = load.i32 vmctx+$instance_flags_offset+ // trapz may_leave, $TRAP_CANNOT_LEAVE_COMPONENT//// ;; set may_block to false, saving the old value to restore// ;; later, but only if the component instances differ and@@ -1527,17 +1526,13 @@ impl<'a> TrampolineCompiler<'a> {fn check_may_leave_instance(&mut self, instance: RuntimeComponentInstanceIndex) {let vmctx = self.builder.func.dfg.block_params(self.block0)[0];- let flags = self.alias_regions.vmcomponent_instance_flags(+ let may_leave = self.alias_regions.vmcomponent_instance_may_leave(&mut self.builder.cursor(),vmctx,instance,);- let may_leave_bit = self- .builder- .ins()- .band_imm_u(flags, i64::from(FLAG_MAY_LEAVE));let (mut traps, builder) = self.traps();- traps.trapz(builder, may_leave_bit, TRAP_CANNOT_LEAVE_COMPONENT);+ traps.trapz(builder, may_leave, TRAP_CANNOT_LEAVE_COMPONENT);}fn traps(diff --git a/crates/environ/src/component/vmcomponent_offsets.rs b/crates/environ/src/component/vmcomponent_offsets.rsindex 4983314fc5..9c5f3b3308 100644--- a/crates/environ/src/component/vmcomponent_offsets.rs+++ b/crates/environ/src/component/vmcomponent_offsets.rs@@ -4,7 +4,7 @@// magic: u32,// builtins: &'static VMComponentBuiltins,// limits: *const VMStoreContext,-// flags: [VMGlobalDefinition; component.num_runtime_component_instances],+// may_leave: [VMGlobalDefinition; component.num_runtime_component_instances],// task_may_block: u32,// trampoline_func_refs: [VMFuncRef; component.num_trampolines],// unsafe_intrinsics: [VMFuncRef; component.num_unsafe_intrinsics],@@ -26,10 +26,6 @@ use crate::component::*;/// double-checked on `VMComponentContext::from_opaque`.pub const VMCOMPONENT_MAGIC: u32 = u32::from_le_bytes(*b"comp");-/// Flag for the `VMComponentContext::flags` field which corresponds to the-/// canonical ABI flag `may_leave`-pub const FLAG_MAY_LEAVE: i32 = 1 << 0;-/// Runtime offsets within a `VMComponentContext` for a specific component.#[derive(Debug, Clone, Copy)]pub struct VMComponentOffsets<P> {@@ -63,7 +59,7 @@ pub struct VMComponentOffsets<P> {magic: u32,builtins: u32,vm_store_context: u32,- flags: u32,+ may_leave: u32,task_may_block: u32,trampoline_func_refs: u32,intrinsic_func_refs: u32,@@ -132,7 +128,7 @@ impl<P: PtrSize> VMComponentOffsets<P> {magic: 0,builtins: 0,vm_store_context: 0,- flags: 0,+ may_leave: 0,task_may_block: 0,trampoline_func_refs: 0,intrinsic_func_refs: 0,@@ -176,7 +172,7 @@ impl<P: PtrSize> VMComponentOffsets<P> {size(builtins) = ret.ptr.size(),size(vm_store_context) = ret.ptr.size(),align(16),- size(flags) = cmul(ret.num_runtime_component_instances, ret.ptr.size_of_vmglobal_definition()),+ size(may_leave) = cmul(ret.num_runtime_component_instances, ret.ptr.size_of_vmglobal_definition()),size(task_may_block) = ret.ptr.size_of_vmglobal_definition(),align(u32::from(ret.ptr.size())),size(trampoline_func_refs) = cmul(ret.num_trampolines, ret.ptr.size_of_vm_func_ref()),@@ -218,11 +214,11 @@ impl<P: PtrSize> VMComponentOffsets<P> {self.builtins}- /// The offset of the `flags` field.+ /// The offset of the `may_leave` flag for the given component instance.#[inline]- pub fn instance_flags(&self, index: RuntimeComponentInstanceIndex) -> u32 {+ pub fn may_leave(&self, index: RuntimeComponentInstanceIndex) -> u32 {assert!(index.as_u32() < self.num_runtime_component_instances);- self.flags + index.as_u32() * u32::from(self.ptr.size_of_vmglobal_definition())+ self.may_leave + index.as_u32() * u32::from(self.ptr.size_of_vmglobal_definition())}/// The offset of the `task_may_block` field.diff --git a/crates/environ/src/fact/trampoline.rs b/crates/environ/src/fact/trampoline.rsindex d046a998b7..4539ad13ec 100644--- a/crates/environ/src/fact/trampoline.rs+++ b/crates/environ/src/fact/trampoline.rs@@ -16,13 +16,12 @@//! can be somewhat arbitrary, an intentional decision.use crate::component::{- CanonicalAbiInfo, ComponentTypesBuilder, FLAG_MAY_LEAVE, FixedEncoding as FE, FlatType,- InterfaceType, MAX_FLAT_ASYNC_PARAMS, MAX_FLAT_PARAMS, PREPARE_ASYNC_NO_RESULT,- PREPARE_ASYNC_WITH_RESULT, START_FLAG_ASYNC_CALLEE, StringEncoding, Transcode,- TypeComponentLocalErrorContextTableIndex, TypeEnumIndex, TypeFixedLengthListIndex,- TypeFlagsIndex, TypeFutureTableIndex, TypeListIndex, TypeMapIndex, TypeOptionIndex,- TypeRecordIndex, TypeResourceTableIndex, TypeResultIndex, TypeStreamTableIndex, TypeTupleIndex,- TypeVariantIndex, VariantInfo,+ CanonicalAbiInfo, ComponentTypesBuilder, FixedEncoding as FE, FlatType, InterfaceType,+ MAX_FLAT_ASYNC_PARAMS, MAX_FLAT_PARAMS, PREPARE_ASYNC_NO_RESULT, PREPARE_ASYNC_WITH_RESULT,+ START_FLAG_ASYNC_CALLEE, StringEncoding, Transcode, TypeComponentLocalErrorContextTableIndex,+ TypeEnumIndex, TypeFixedLengthListIndex, TypeFlagsIndex, TypeFutureTableIndex, TypeListIndex,+ TypeMapIndex, TypeOptionIndex, TypeRecordIndex, TypeResourceTableIndex, TypeResultIndex,+ TypeStreamTableIndex, TypeTupleIndex, TypeVariantIndex, VariantInfo,};use crate::fact::signature::Signature;use crate::fact::transcode::Transcoder;@@ -701,9 +700,9 @@ impl<'a, 'b> Compiler<'a, 'b> {.map(|(i, ty)| (i as u32, *ty)).collect::<Vec<_>>();- self.set_flag(adapter.lift.flags, FLAG_MAY_LEAVE, false);+ let saved = self.clear_may_leave(adapter.lift.flags);self.translate_params(adapter, ¶m_locals);- self.set_flag(adapter.lift.flags, FLAG_MAY_LEAVE, true);+ self.restore_may_leave(adapter.lift.flags, saved);self.finish();}@@ -727,7 +726,7 @@ impl<'a, 'b> Compiler<'a, 'b> {.map(|(i, ty)| (i as u32, *ty)).collect::<Vec<_>>();- self.set_flag(adapter.lower.flags, FLAG_MAY_LEAVE, false);+ let saved = self.clear_may_leave(adapter.lower.flags);// Note that we pass `param_locals` as _both_ the `param_locals` and// `result_locals` parameters to `translate_results`. That's because// the _parameters_ to `task.return` are actually the _results_ that the@@ -739,7 +738,7 @@ impl<'a, 'b> Compiler<'a, 'b> {// the import is lowered async, in which case `translate_results` will// use that pointer to store the results.self.translate_results(adapter, ¶m_locals, ¶m_locals);- self.set_flag(adapter.lower.flags, FLAG_MAY_LEAVE, true);+ self.restore_may_leave(adapter.lower.flags, saved);self.finish()}@@ -763,11 +762,12 @@ impl<'a, 'b> Compiler<'a, 'b> {// This inserts the initial check required by `canon_lower` that the// caller instance can be left and additionally checks the// flags on the callee if necessary whether it can be entered.- self.trap_if_not_flag(- adapter.lower.flags,- FLAG_MAY_LEAVE,- Trap::CannotLeaveComponent,- );+ //+ // The loaded `may_leave` value is saved into `saved_lower_may_leave`+ // so that it can be restored after results are translated below+ // without reloading the global.+ let saved_lower_may_leave =+ self.trap_if_not_may_leave(adapter.lower.flags, Trap::CannotLeaveComponent);let old_task_may_block = if self.module.tunables.concurrency_support {// Save, clear, and later restore the `may_block` field.@@ -823,8 +823,8 @@ impl<'a, 'b> Compiler<'a, 'b> {None};- // Perform the translation of arguments. Note that `FLAG_MAY_LEAVE` is- // cleared around this invocation for the callee as per the+ // Perform the translation of arguments. Note that the `may_leave` flag+ // is cleared around this invocation for the callee as per the// `canon_lift` definition in the spec. Additionally note that the// precise ordering of traps here is not required since internal state// is not visible to either instance and a trap will "lock down" both@@ -832,10 +832,32 @@ impl<'a, 'b> Compiler<'a, 'b> {// reorder lifts/lowers and flags and such as is necessary and// convenient here.//- // TODO: if translation doesn't actually call any functions in either- // instance then there's no need to set/clear the flag here and that can- // be optimized away.- self.set_flag(adapter.lift.flags, FLAG_MAY_LEAVE, false);+ // The clear-and-restore is structured (a constant `0` store to clear,+ // then a store of the saved original value to restore) so that if+ // translation doesn't actually call any functions in either instance+ // then a future dead-store elimination pass in Cranelift can remove all+ // the flag juggling entirely (other than trapping when `!may_leave`):+ //+ // may_leave = load vmctx+MAY_LEAVE_OFFSET ;; (0)+ // trapz may_leave+ //+ // ...+ //+ // zero = iconst 0+ // store zero, vmctx+MAY_LEAVE_OFFSET ;; (1)+ //+ // ...+ //+ // store may_leave, vmctx+MAY_LEAVE_OFFSET ;; (2)+ //+ // First, the dead-store elimination pass will see that the the store at+ // (1) is dead and remove it. Then, the idempotent-store eliminator will+ // recognize that the store at (2) is storing the same value that the+ // memory location already contains and it will also be removed. The+ // more we can reuse locals to make this idempotency obvious, rather+ // than force Cranelift's optimizer to rediscover this information, the+ // better.+ let saved_lift_may_leave = self.clear_may_leave(adapter.lift.flags);let param_locals = lower_sig.params.iter()@@ -843,7 +865,7 @@ impl<'a, 'b> Compiler<'a, 'b> {.map(|(i, ty)| (i as u32, *ty)).collect::<Vec<_>>();self.translate_params(adapter, ¶m_locals);- self.set_flag(adapter.lift.flags, FLAG_MAY_LEAVE, true);+ self.restore_may_leave(adapter.lift.flags, saved_lift_may_leave);// With all the arguments on the stack the actual target function is// now invoked. The core wasm results of the function are then placed@@ -882,12 +904,9 @@ impl<'a, 'b> Compiler<'a, 'b> {// order of everything doesn't matter since intermediate states cannot// be witnessed, hence the setting of flags here to encapsulate both// liftings and lowerings.- //- // TODO: like above the management of the `MAY_LEAVE` flag can probably- // be elided here for "simple" results.- self.set_flag(adapter.lower.flags, FLAG_MAY_LEAVE, false);+ self.set_may_leave_false(adapter.lower.flags);self.translate_results(adapter, ¶m_locals, &result_locals);- self.set_flag(adapter.lower.flags, FLAG_MAY_LEAVE, true);+ self.restore_may_leave(adapter.lower.flags, saved_lower_may_leave);// And finally post-return state is handled here once all results/etc// are all translated.@@ -3575,26 +3594,58 @@ impl<'a, 'b> Compiler<'a, 'b> {}}- fn trap_if_not_flag(&mut self, flags_global: GlobalIndex, flag_to_test: i32, trap: Trap) {+ /// Loads the `may_leave` flag for the given instance, traps with `trap` if+ /// it is not set, and returns a temporary local holding the loaded value+ /// so that it can later be restored with `restore_may_leave` without+ /// reloading the global.+ ///+ /// The `may_leave` flag is a boolean (0 or 1) so no masking is required.+ fn trap_if_not_may_leave(&mut self, flags_global: GlobalIndex, trap: Trap) -> TempLocal {self.instruction(GlobalGet(flags_global.as_u32()));- self.instruction(I32Const(flag_to_test));- self.instruction(I32And);+ // Save the flag's value (known to be `true` whenever the trap below is+ // not taken) into a temporary for later restoration.+ let saved = self.local_tee_new_tmp(ValType::I32);self.instruction(I32Eqz);self.instruction(If(BlockType::Empty));self.trap(trap);self.instruction(End);+ saved}- fn set_flag(&mut self, flags_global: GlobalIndex, flag_to_set: i32, value: bool) {+ /// Saves the current value of the `may_leave` flag into a fresh temporary+ /// local (returned) and then clears the flag to `false`.+ fn clear_may_leave(&mut self, flags_global: GlobalIndex) -> TempLocal {self.instruction(GlobalGet(flags_global.as_u32()));- if value {- self.instruction(I32Const(flag_to_set));- self.instruction(I32Or);- } else {- self.instruction(I32Const(!flag_to_set));- self.instruction(I32And);- }+ let saved = self.local_set_new_tmp(ValType::I32);+ self.set_may_leave_false(flags_global);+ saved+ }++ /// Sets the `may_leave` flag to `false` by storing a constant `0`.+ ///+ /// Since there is only a single flag there is no need to reload the global+ /// and mask: storing `0` is sufficient.+ fn set_may_leave_false(&mut self, flags_global: GlobalIndex) {+ self.instruction(I32Const(0));+ self.instruction(GlobalSet(flags_global.as_u32()));+ }++ /// Restores the `may_leave` flag to the value previously saved in `saved`+ /// (via `clear_may_leave` or `trap_if_not_may_leave`) and frees the+ /// temporary local.+ ///+ /// Storing the previously-loaded value (rather than reloading the global+ /// and or-ing in the flag bit) makes it clear in the generated CLIF that+ /// the same value that was there before is being written back. Combined+ /// with the constant `0` store in `set_may_leave_false`, this lets a future+ /// dead-store-elimination pass remove the clear-to-`false` store which will+ /// then allow our idempotent-store elimination to remove this restore for+ /// adapters whose body never touches the flag (e.g. simple inlined+ /// callees).+ fn restore_may_leave(&mut self, flags_global: GlobalIndex, saved: TempLocal) {+ self.instruction(LocalGet(saved.idx));self.instruction(GlobalSet(flags_global.as_u32()));+ self.free_temp_local(saved);}fn assert_aligned(&mut self, ty: &InterfaceType, mem: &Memory) {diff --git a/crates/wasmtime/src/runtime/vm/component.rs b/crates/wasmtime/src/runtime/vm/component.rsindex e088657a6c..de21c6738b 100644--- a/crates/wasmtime/src/runtime/vm/component.rs+++ b/crates/wasmtime/src/runtime/vm/component.rs@@ -365,8 +365,8 @@ impl ComponentInstance {#[inline]pub fn instance_flags(&self, instance: RuntimeComponentInstanceIndex) -> InstanceFlags {unsafe {- let ptr = self- .vmctx_plus_offset_raw::<VMGlobalDefinition>(self.offsets.instance_flags(instance));+ let ptr =+ self.vmctx_plus_offset_raw::<VMGlobalDefinition>(self.offsets.may_leave(instance));InstanceFlags(SendSyncPtr::new(ptr))}}@@ -704,9 +704,9 @@ impl ComponentInstance {let i = RuntimeComponentInstanceIndex::from_u32(i);let mut def = VMGlobalDefinition::new();// SAFETY: this is a valid initialization of all globals which are- // 32-bit values.+ // 32-bit values. The `may_leave` flag starts out `true`.unsafe {- *def.as_i32_mut() = FLAG_MAY_LEAVE;+ *def.as_i32_mut() = 1;self.instance_flags(i).as_raw().write(def);}}@@ -1062,17 +1062,13 @@ impl InstanceFlags {#[inline]pub unsafe fn may_leave(&self) -> bool {- unsafe { *self.as_raw().as_ref().as_i32() & FLAG_MAY_LEAVE != 0 }+ unsafe { *self.as_raw().as_ref().as_i32() != 0 }}#[inline]pub unsafe fn set_may_leave(&mut self, val: bool) {unsafe {- if val {- *self.as_raw().as_mut().as_i32_mut() |= FLAG_MAY_LEAVE;- } else {- *self.as_raw().as_mut().as_i32_mut() &= !FLAG_MAY_LEAVE;- }+ *self.as_raw().as_mut().as_i32_mut() = val as i32;}}diff --git a/tests/disas/component-may-leave-without-signals-based-traps.wat b/tests/disas/component-may-leave-without-signals-based-traps.watindex ef878974ae..d9834361ea 100644--- a/tests/disas/component-may-leave-without-signals-based-traps.wat+++ b/tests/disas/component-may-leave-without-signals-based-traps.wat@@ -25,9 +25,9 @@;; movq 8(%rcx), %rcx;; movq %rcx, 0x38(%rax);; movl 0x20(%rdi), %eax-;; testl $1, %eax-;; je 0x13e-;; fe: movq 8(%rdi), %rax+;; testl %eax, %eax+;; je 0x13b+;; fb: movq 8(%rdi), %rax;; movq (%rax), %rax;; xorl %ecx, %ecx;; movl %ecx, %esi@@ -36,21 +36,21 @@;; movl %ecx, %ecx;; callq *%rax;; cmpq $-1, %rax-;; je 0x129-;; 11c: movq (%rsp), %rbx+;; je 0x126+;; 119: movq (%rsp), %rbx;; addq $0x10, %rsp;; movq %rbp, %rsp;; popq %rbp;; retq-;; 129: movq %rbx, %rsi-;; 12c: movq 0x10(%rsi), %rax-;; 130: movq 0x148(%rax), %rax-;; 137: movq %rbx, %rdi-;; 13a: callq *%rax-;; 13c: ud2-;; 13e: movl $0x17, %esi-;; 143: movq %rbx, %rdi-;; 146: callq 0x6a-;; 14b: movq %rbx, %rdi-;; 14e: callq 0x9b-;; 153: ud2+;; 126: movq %rbx, %rsi+;; 129: movq 0x10(%rsi), %rax+;; 12d: movq 0x148(%rax), %rax+;; 134: movq %rbx, %rdi+;; 137: callq *%rax+;; 139: ud2+;; 13b: movl $0x17, %esi+;; 140: movq %rbx, %rdi+;; 143: callq 0x6a+;; 148: movq %rbx, %rdi+;; 14b: callq 0x9b+;; 150: ud2diff --git a/tests/disas/component-model/direct-adapter-calls-inlining.wat b/tests/disas/component-model/direct-adapter-calls-inlining.watindex d990e66dc0..d5663715aa 100644--- a/tests/disas/component-model/direct-adapter-calls-inlining.wat+++ b/tests/disas/component-model/direct-adapter-calls-inlining.wat@@ -92,30 +92,25 @@;; @00ee v4 = load.i64 notrap aligned readonly can_move region2 v0+72;; v14 = load.i64 notrap aligned readonly can_move region3 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+;; v17 = icmp eq v15, v13 ; v13 = 0+;; brif v17, block9, block10;;;; block9:-;; 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+;; v21 = load.i64 notrap aligned readonly can_move region6 v4+88+;; v20 = load.i64 notrap aligned readonly can_move region5 v4+104+;; v19 = iconst.i32 23+;; try_call_indirect v21(v20, v4, v19), sig1, block11, [ context v4, default: block8(exn0) ] ; v19 = 23;;;; block11:;; trap user12;;;; block10:-;; v28 = load.i64 notrap aligned readonly can_move region7 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+;; v26 = load.i64 notrap aligned readonly can_move region7 v4+112+;; v27 = load.i32 notrap aligned region4 v26+;; v43 = iconst.i32 0+;; store notrap aligned region4 v43, v26 ; v43 = 0+;; store notrap aligned region4 v27, v26;; jump block13;;;; block13:@@ -125,21 +120,17 @@;; jump block12;;;; block12:-;; 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+;; v44 = iconst.i32 0+;; store notrap aligned region4 v44, v14 ; v44 = 0+;; store.i32 notrap aligned region4 v15, v14;; jump block7;;;; block7:;; jump block4;;;; block5:-;; v25 = iconst.i32 49-;; call_indirect.i64 sig1, v23(v22, v4, v25) ; v25 = 49+;; v23 = iconst.i32 49+;; call_indirect.i64 sig1, v21(v20, v4, v23) ; v23 = 49;; trap user12;;;; block4:@@ -152,6 +143,6 @@;; @00f0 jump block1;;;; block1:-;; v53 = iconst.i32 1276-;; @00f0 return v53 ; v53 = 1276+;; v37 = iconst.i32 1276+;; @00f0 return v37 ; v37 = 1276;; }diff --git a/tests/disas/component-model/direct-adapter-calls-x64.wat b/tests/disas/component-model/direct-adapter-calls-x64.watindex 3dcbe79db1..8dd507783d 100644--- a/tests/disas/component-model/direct-adapter-calls-x64.wat+++ b/tests/disas/component-model/direct-adapter-calls-x64.wat@@ -85,65 +85,60 @@;; movq %rsp, %rbp;; movq 8(%rdi), %r10;; movq 0x18(%r10), %r10-;; addq $0x50, %r10+;; addq $0x60, %r10;; cmpq %rsp, %r10-;; ja 0x147-;; 79: subq $0x40, %rsp-;; movq %rbx, 0x10(%rsp)-;; movq %r12, 0x18(%rsp)-;; movq %r13, 0x20(%rsp)-;; movq %r14, 0x28(%rsp)-;; movq %r15, 0x30(%rsp)+;; ja 0x13e+;; 79: subq $0x50, %rsp+;; movq %rbx, 0x20(%rsp)+;; movq %r12, 0x28(%rsp)+;; movq %r13, 0x30(%rsp)+;; movq %r14, 0x38(%rsp)+;; movq %r15, 0x40(%rsp);; movq %rdi, (%rsp);; movq (%rsp), %rdi-;; movq 0x88(%rdi), %r8-;; movl (%r8), %eax-;; movq %r8, 8(%rsp)-;; testl $1, %eax-;; je 0x115-;; b8: movq (%rsp), %rdi+;; movq 0x88(%rdi), %rcx+;; movl (%rcx), %esi+;; movq %rcx, 0x10(%rsp)+;; testl %esi, %esi+;; movq %rsi, 8(%rsp)+;; je 0x10c+;; b9: movq (%rsp), %rdi;; movq 0x70(%rdi), %rax;; movl (%rax), %ecx-;; movq %rcx, %rsi-;; andl $0xfffffffe, %esi-;; movl %esi, (%rax)-;; orl $1, %ecx+;; movl $0, (%rax);; movl %ecx, (%rax);; movq 0x48(%rdi), %rdi;; movq (%rsp), %rsi;; callq 0-;; ├─╼ exception frame offset: SP = FP - 0x40-;; ╰─╼ exception handler: default handler, context at [SP+0x0], handler=0x12e-;; movq 8(%rsp), %r8-;; movl (%r8), %ecx-;; movq %rcx, %rsi-;; andl $0xfffffffe, %esi-;; movl %esi, (%r8)-;; orl $1, %ecx-;; movl %ecx, (%r8)-;; movq 0x10(%rsp), %rbx-;; movq 0x18(%rsp), %r12-;; movq 0x20(%rsp), %r13-;; movq 0x28(%rsp), %r14-;; movq 0x30(%rsp), %r15-;; addq $0x40, %rsp+;; ├─╼ exception frame offset: SP = FP - 0x50+;; ╰─╼ exception handler: default handler, context at [SP+0x0], handler=0x125+;; movq 0x10(%rsp), %rcx+;; movl $0, (%rcx)+;; movq 8(%rsp), %rsi+;; movl %esi, (%rcx)+;; movq 0x20(%rsp), %rbx+;; movq 0x28(%rsp), %r12+;; movq 0x30(%rsp), %r13+;; movq 0x38(%rsp), %r14+;; movq 0x40(%rsp), %r15+;; addq $0x50, %rsp;; movq %rbp, %rsp;; popq %rbp;; retq-;; 115: movq (%rsp), %rcx-;; 119: movq 0x58(%rcx), %rax-;; 11d: movq 0x68(%rcx), %rdi-;; 121: movl $0x17, %edx-;; 126: movq (%rsp), %rsi-;; 12a: callq *%rax-;; ├─╼ exception frame offset: SP = FP - 0x40-;; ╰─╼ exception handler: default handler, context at [SP+0x0], handler=0x12e-;; 12c: ud2-;; 12e: movq (%rsp), %rcx-;; 132: movq 0x58(%rcx), %rax-;; 136: movq 0x68(%rcx), %rdi-;; 13a: movl $0x31, %edx-;; 13f: movq (%rsp), %rsi-;; 143: callq *%rax-;; 145: ud2-;; 147: ud2+;; 10c: movq (%rsp), %rcx+;; 110: movq 0x58(%rcx), %rax+;; 114: movq 0x68(%rcx), %rdi+;; 118: movl $0x17, %edx+;; 11d: movq (%rsp), %rsi+;; 121: callq *%rax+;; ├─╼ exception frame offset: SP = FP - 0x50+;; ╰─╼ exception handler: default handler, context at [SP+0x0], handler=0x125+;; 123: ud2+;; 125: movq (%rsp), %rcx+;; 129: movq 0x58(%rcx), %rax+;; 12d: movq 0x68(%rcx), %rdi+;; 131: movl $0x31, %edx+;; 136: movq (%rsp), %rsi+;; 13a: callq *%rax+;; 13c: ud2+;; 13e: ud2diff --git a/tests/disas/component-model/direct-adapter-calls.wat b/tests/disas/component-model/direct-adapter-calls.watindex 5e24a00ea0..2dc06561d0 100644--- a/tests/disas/component-model/direct-adapter-calls.wat+++ b/tests/disas/component-model/direct-adapter-calls.wat@@ -121,56 +121,47 @@;; block4:;; @0080 v9 = load.i64 notrap aligned readonly can_move region2 v0+136;; @0080 v10 = load.i32 notrap aligned region3 v9-;; @0082 v11 = iconst.i32 1-;; @0084 v12 = band v10, v11 ; v11 = 1;; @0075 v4 = iconst.i32 0-;; @0085 v14 = icmp eq v12, v4 ; v4 = 0-;; @0086 brif v14, block7, block8+;; @0084 v12 = icmp eq v10, v4 ; v4 = 0+;; @0085 brif v12, block7, block8;;;; block7:-;; @008a v18 = load.i64 notrap aligned readonly can_move region5 v0+88-;; @008a v17 = load.i64 notrap aligned readonly can_move region4 v0+104-;; @0088 v16 = iconst.i32 23-;; @008a try_call_indirect v18(v17, v0, v16), sig0, block9, [ context v0, default: block6(exn0) ] ; v16 = 23+;; @0089 v16 = load.i64 notrap aligned readonly can_move region5 v0+88+;; @0089 v15 = load.i64 notrap aligned readonly can_move region4 v0+104+;; @0087 v14 = iconst.i32 23+;; @0089 try_call_indirect v16(v15, v0, v14), sig0, block9, [ context v0, default: block6(exn0) ] ; v14 = 23;;;; block9:-;; @008c trap user12+;; @008b trap user12;;;; block8:-;; @008e v19 = load.i64 notrap aligned readonly can_move region6 v0+112-;; @008e v20 = load.i32 notrap aligned region3 v19-;; @0090 v21 = iconst.i32 -2-;; @0092 v22 = band v20, v21 ; v21 = -2-;; @0093 store notrap aligned region3 v22, v19-;; v48 = iconst.i32 1-;; v49 = bor v20, v48 ; v48 = 1-;; @009c store notrap aligned region3 v49, v19-;; @009e v29 = load.i64 notrap aligned readonly can_move region7 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 region3 v9-;; v50 = iconst.i32 -2-;; v51 = band v32, v50 ; v50 = -2-;; @00a7 store notrap aligned region3 v51, v9-;; v52 = iconst.i32 1-;; v53 = bor v32, v52 ; v52 = 1-;; @00b0 store notrap aligned region3 v53, v9-;; @00b2 jump block5(v30)+;; @008d v17 = load.i64 notrap aligned readonly can_move region6 v0+112+;; @008d v18 = load.i32 notrap aligned region3 v17+;; v30 = iconst.i32 0+;; @0093 store notrap aligned region3 v30, v17 ; v30 = 0+;; @0099 store notrap aligned region3 v18, v17+;; @009b v22 = load.i64 notrap aligned readonly can_move region7 v0+72+;; @009b try_call fn0(v22, v0, v2), sig1, block10(ret0), [ context v0, default: block6(exn0) ]+;;+;; block10(v23: i32):+;; v31 = iconst.i32 0+;; @00a1 store notrap aligned region3 v31, v9 ; v31 = 0+;; @00a7 store.i32 notrap aligned region3 v10, v9+;; @00a9 jump block5(v23);;;; block5(v6: i32):-;; @00b3 jump block2(v6)+;; @00aa jump block2(v6);;;; block3:-;; v54 = load.i64 notrap aligned readonly can_move region5 v0+88-;; v55 = load.i64 notrap aligned readonly can_move region4 v0+104-;; @00b6 v41 = iconst.i32 49-;; @00b8 call_indirect sig0, v54(v55, v0, v41) ; v41 = 49-;; @00ba trap user12+;; v32 = load.i64 notrap aligned readonly can_move region5 v0+88+;; v33 = load.i64 notrap aligned readonly can_move region4 v0+104+;; @00ad v27 = iconst.i32 49+;; @00af call_indirect sig0, v32(v33, v0, v27) ; v27 = 49+;; @00b1 trap user12;;;; block2(v5: i32):-;; @00bc jump block1(v5)+;; @00b3 jump block1(v5);;;; block1(v3: i32):-;; @00bc return v3+;; @00b3 return v3;; }diff --git a/tests/disas/riscv64-component-builtins-asm.wat b/tests/disas/riscv64-component-builtins-asm.watindex 434980861b..9a71f7ea30 100644--- a/tests/disas/riscv64-component-builtins-asm.wat+++ b/tests/disas/riscv64-component-builtins-asm.wat@@ -17,17 +17,16 @@;; sd s0, 0(sp);; mv s0, sp;; addi sp, sp, -0x10-;; sd s5, 8(sp)-;; sd s9, 0(sp)-;; mv s5, a1-;; mv s9, a2+;; sd s4, 8(sp)+;; sd s8, 0(sp)+;; mv s4, a1+;; mv s8, a2;; mv a3, s0;; ld a1, 8(a1);; sd a3, 0x30(a1);; ld a2, 8(s0);; sd a2, 0x38(a1);; lw a1, 0x20(a0)-;; andi a1, a1, 1;; sext.w a1, a1;; bnez a1, 8;; .byte 0x00, 0x00, 0x00, 0x00@@ -39,20 +38,20 @@;; srai a1, a1, 0x20;; slli a2, a4, 0x20;; srai a2, a2, 0x20-;; mv a3, s9+;; mv a3, s8;; slli a3, a3, 0x20;; srai a3, a3, 0x20;; jalr a5;; addi a1, zero, -1;; beq a0, a1, 0x20-;; ld s5, 8(sp)-;; ld s9, 0(sp)+;; ld s4, 8(sp)+;; ld s8, 0(sp);; addi sp, sp, 0x10;; ld ra, 8(sp);; ld s0, 0(sp);; addi sp, sp, 0x10;; ret-;; mv a1, s5+;; mv a1, s4;; ld a0, 0x10(a1);; ld a2, 0x148(a0);; mv a0, a1diff --git a/tests/disas/riscv64-component-builtins.wat b/tests/disas/riscv64-component-builtins.watindex bee89c8813..46b0e1fff2 100644--- a/tests/disas/riscv64-component-builtins.wat+++ b/tests/disas/riscv64-component-builtins.wat@@ -27,25 +27,23 @@;; v5 = get_return_address.i64;; store notrap aligned region2 v5, v3+56;; v6 = load.i32 notrap aligned region3 v0+32-;; v7 = iconst.i32 1-;; v8 = band v6, v7 ; v7 = 1-;; trapz v8, user26-;; v11 = load.i64 notrap aligned readonly region4 v0+8-;; v12 = load.i64 notrap aligned readonly v11+16-;; v9 = iconst.i32 0-;; v13 = call_indirect sig0, v12(v0, v9, v9, v2) ; v9 = 0, v9 = 0-;; v14 = iconst.i64 -1-;; v15 = icmp ne v13, v14 ; v14 = -1-;; brif v15, block2, block1+;; trapz v6, user26+;; v9 = load.i64 notrap aligned readonly region4 v0+8+;; v10 = load.i64 notrap aligned readonly v9+16+;; v7 = iconst.i32 0+;; v11 = call_indirect sig0, v10(v0, v7, v7, v2) ; v7 = 0, v7 = 0+;; v12 = iconst.i64 -1+;; v13 = icmp ne v11, v12 ; v12 = -1+;; brif v13, block2, block1;;;; block1 cold:-;; v16 = load.i64 notrap aligned readonly can_move region5 v1+16-;; v17 = load.i64 notrap aligned readonly can_move v16+328-;; call_indirect sig1, v17(v1)+;; v14 = load.i64 notrap aligned readonly can_move region5 v1+16+;; v15 = load.i64 notrap aligned readonly can_move v14+328+;; call_indirect sig1, v15(v1);; trap user1;;;; block2:-;; brif.i64 v13, block3, block4+;; brif.i64 v11, block3, block4;;;; block3:;; jump block4