7795a230f2
* Implement support for `async` functions in Wasmtime This is an implementation of [RFC 2] in Wasmtime which is to support `async`-defined host functions. At a high level support is added by executing WebAssembly code that might invoke an asynchronous host function on a separate native stack. When the host function's future is not ready we switch back to the main native stack to continue execution. There's a whole bunch of details in this commit, and it's a bit much to go over them all here in this commit message. The most important changes here are: * A new `wasmtime-fiber` crate has been written to manage the low-level details of stack-switching. Unixes use `mmap` to allocate a stack and Windows uses the native fibers implementation. We'll surely want to refactor this to move stack allocation elsewhere in the future. Fibers are intended to be relatively general with a lot of type paremters to fling values back and forth across suspension points. The whole crate is a giant wad of `unsafe` unfortunately and involves handwritten assembly with custom dwarf CFI directives to boot. Definitely deserves a close eye in review! * The `Store` type has two new methods -- `block_on` and `on_fiber` which bridge between the async and non-async worlds. Lots of unsafe fiddly bits here as we're trying to communicate context pointers between disparate portions of the code. Extra eyes and care in review is greatly appreciated. * The APIs for binding `async` functions are unfortunately pretty ugly in `Func`. This is mostly due to language limitations and compiler bugs (I believe) in Rust. Instead of `Func::wrap` we have a `Func::wrapN_async` family of methods, and we've also got a whole bunch of `Func::getN_async` methods now too. It may be worth rethinking the API of `Func` to try to make the documentation page actually grok'able. This isn't super heavily tested but the various test should suffice for engaging hopefully nearly all the infrastructure in one form or another. This is just the start though! [RFC 2]: https://github.com/bytecodealliance/rfcs/pull/2 * Add wasmtime-fiber to publish script * Save vector/float registers on ARM too. * Fix a typo * Update lock file * Implement periodically yielding with fuel consumption This commit implements APIs on `Store` to periodically yield execution of futures through the consumption of fuel. When fuel runs out a future's execution is yielded back to the caller, and then upon resumption fuel is re-injected. The goal of this is to allow cooperative multi-tasking with futures. * Fix compile without async * Save/restore the frame pointer in fiber switching Turns out this is another caller-saved register! * Simplify x86_64 fiber asm Take a leaf out of aarch64's playbook and don't have extra memory to load/store these arguments, instead leverage how `wasmtime_fiber_switch` already loads a bunch of data into registers which we can then immediately start using on a fiber's start without any extra memory accesses. * Add x86 support to wasmtime-fiber * Add ARM32 support to fiber crate * Make fiber build file probing more flexible * Use CreateFiberEx on Windows * Remove a stray no-longer-used trait declaration * Don't reach into `Caller` internals * Tweak async fuel to eventually run out. With fuel it's probably best to not provide any way to inject infinite fuel. * Fix some typos * Cleanup asm a bit * Use a shared header file to deduplicate some directives * Guarantee hidden visibility for functions * Enable gc-sections on macOS x86_64 * Add `.type` annotations for ARM * Update lock file * Fix compile error * Review comments
108 lines
3.1 KiB
ArmAsm
108 lines
3.1 KiB
ArmAsm
// A WORD OF CAUTION
|
|
//
|
|
// This entire file basically needs to be kept in sync with itself. It's not
|
|
// really possible to modify just one bit of this file without understanding
|
|
// all the other bits. Documentation tries to reference various bits here and
|
|
// there but try to make sure to read over everything before tweaking things!
|
|
//
|
|
// This file is modeled after x86_64.S and comments are not copied over. For
|
|
// reference be sure to review the other file. Note that the pointer size is
|
|
// different so the reserved space at the top of the stack is 8 bytes, not 16
|
|
// bytes. Still two pointers though.
|
|
|
|
#include "header.h"
|
|
|
|
// fn(top_of_stack: *mut u8)
|
|
HIDDEN(wasmtime_fiber_switch)
|
|
GLOBL(wasmtime_fiber_switch)
|
|
TYPE(wasmtime_fiber_switch)
|
|
FUNCTION(wasmtime_fiber_switch):
|
|
// Load our stack-to-use
|
|
mov 0x4(%esp), %eax
|
|
mov -0x8(%eax), %ecx
|
|
|
|
// Save callee-saved registers
|
|
push %ebp
|
|
push %ebx
|
|
push %esi
|
|
push %edi
|
|
|
|
// Save our current stack and jump to the stack-to-use
|
|
mov %esp, -0x8(%eax)
|
|
mov %ecx, %esp
|
|
|
|
// Restore callee-saved registers
|
|
pop %edi
|
|
pop %esi
|
|
pop %ebx
|
|
pop %ebp
|
|
ret
|
|
SIZE(wasmtime_fiber_switch)
|
|
|
|
// fn(
|
|
// top_of_stack: *mut u8,
|
|
// entry_point: extern fn(*mut u8, *mut u8),
|
|
// entry_arg0: *mut u8,
|
|
// )
|
|
HIDDEN(wasmtime_fiber_init)
|
|
GLOBL(wasmtime_fiber_init)
|
|
TYPE(wasmtime_fiber_init)
|
|
FUNCTION(wasmtime_fiber_init):
|
|
mov 4(%esp), %eax
|
|
|
|
// move top_of_stack to the 2nd argument
|
|
mov %eax, -0x0c(%eax)
|
|
|
|
// move entry_arg0 to the 1st argument
|
|
mov 12(%esp), %ecx
|
|
mov %ecx, -0x10(%eax)
|
|
|
|
// Move our start function to the return address which the `ret` in
|
|
// `wasmtime_fiber_start` will return to.
|
|
lea FUNCTION(wasmtime_fiber_start), %ecx
|
|
mov %ecx, -0x14(%eax)
|
|
|
|
// And move `entry_point` to get loaded into `%ebp` through the context
|
|
// switch. This'll get jumped to in `wasmtime_fiber_start`.
|
|
mov 8(%esp), %ecx
|
|
mov %ecx, -0x18(%eax)
|
|
|
|
// Our stack from top-to-bottom looks like:
|
|
//
|
|
// * 8 bytes of reserved space per unix.rs (two-pointers space)
|
|
// * 8 bytes of arguments (two arguments wasmtime_fiber_start forwards)
|
|
// * 4 bytes of return address
|
|
// * 16 bytes of saved registers
|
|
//
|
|
// Note that after the return address the stack is conveniently 16-byte
|
|
// aligned as required, so we just leave the arguments on the stack in
|
|
// `wasmtime_fiber_start` and immediately do the call.
|
|
lea -0x24(%eax), %ecx
|
|
mov %ecx, -0x08(%eax)
|
|
ret
|
|
SIZE(wasmtime_fiber_init)
|
|
|
|
TYPE(wasmtime_fiber_start)
|
|
FUNCTION(wasmtime_fiber_start):
|
|
.cfi_startproc simple
|
|
.cfi_escape 0x0f, /* DW_CFA_def_cfa_expression */ \
|
|
5, /* the byte length of this expression */ \
|
|
0x74, 0x08, /* DW_OP_breg4 (%esp) + 8 */ \
|
|
0x06, /* DW_OP_deref */ \
|
|
0x23, 0x14 /* DW_OP_plus_uconst 0x14 */
|
|
|
|
.cfi_rel_offset eip, -4
|
|
.cfi_rel_offset ebp, -8
|
|
.cfi_rel_offset ebx, -12
|
|
.cfi_rel_offset esi, -16
|
|
.cfi_rel_offset edi, -20
|
|
|
|
// Our arguments and stack alignment are all prepped by
|
|
// `wasmtime_fiber_init`.
|
|
call *%ebp
|
|
ud2
|
|
.cfi_endproc
|
|
SIZE(wasmtime_fiber_start)
|
|
|
|
FOOTER
|