wasmtime 10.0.0 → 11.0.0

data/ext/cargo-vendor/wiggle-generate-11.0.0/Cargo.toml

@@ -0,0 +1,58 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+name = "wiggle-generate"
+version = "11.0.0"
+authors = [
+    "Pat Hickey <phickey@fastly.com>",
+    "Jakub Konka <kubkon@jakubkonka.com>",
+    "Alex Crichton <alex@alexcrichton.com>",
+]
+include = [
+    "src/**/*",
+    "README.md",
+    "LICENSE",
+]
+description = "Library crate for wiggle code generator."
+readme = "README.md"
+keywords = [
+    "webassembly",
+    "wasm",
+]
+categories = ["wasm"]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[lib]
+
+[dependencies.anyhow]
+version = "1.0.22"
+
+[dependencies.heck]
+version = "0.4"
+
+[dependencies.proc-macro2]
+version = "1.0"
+
+[dependencies.quote]
+version = "1.0"
+
+[dependencies.shellexpand]
+version = "2.0"
+
+[dependencies.syn]
+version = "1.0"
+features = ["full"]
+
+[dependencies.witx]
+version = "0.9.1"

data/ext/cargo-vendor/wiggle-macro-11.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"7bb7f25082bb48f2308ee02b2f3ad3af11acf8be0f156ca29a15e6e9d7a66bed","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","src/lib.rs":"f900ec4ff2b4b5f11d5ed5b15a1d521470fe94ecea2fbff3da1cb1b241df0d17"},"package":"623458d835ce95c15031f812c6e9ca89b5e5b86971dff08d915c1dd411603843"}

data/ext/cargo-vendor/wiggle-macro-11.0.0/Cargo.toml

@@ -0,0 +1,55 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+name = "wiggle-macro"
+version = "11.0.0"
+authors = [
+    "Pat Hickey <phickey@fastly.com>",
+    "Jakub Konka <kubkon@jakubkonka.com>",
+    "Alex Crichton <alex@alexcrichton.com>",
+]
+include = [
+    "src/**/*",
+    "LICENSE",
+]
+description = "Wiggle code generator"
+keywords = [
+    "webassembly",
+    "wasm",
+]
+categories = ["wasm"]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[lib]
+test = false
+doctest = false
+proc-macro = true
+
+[dependencies.proc-macro2]
+version = "1.0"
+
+[dependencies.quote]
+version = "1.0"
+
+[dependencies.syn]
+version = "1.0"
+features = ["full"]
+
+[dependencies.wiggle-generate]
+version = "=11.0.0"
+
+[dev-dependencies]
+
+[features]
+wiggle_metadata = []

data/ext/cargo-vendor/winch-codegen-0.9.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"566e29d668104c493912fb2d445ac1807934dcf800e830c52409225a79861de3","LICENSE":"a6c48161a09acc75a0e25503bab66a731eb5fba5392ed4bb4743e4ba5085327a","build.rs":"d19fe439db9b48a8bf91af26001c20ea6010633133bc52a13679720187a7cf1b","src/abi/local.rs":"9ad1d5acd30f25ca4f5fdc162164a885544b69ebf61e80d779c71e509636e5f0","src/abi/mod.rs":"7a66a3ba0ed65480e7fbcf0020b50eb0e7902d3e2e7a1e6ce71e7ed0b0f2c9b4","src/codegen/call.rs":"bc6ac03bbf07d2856c01118a1821e2c74928a92eee92eabe73804208317cd06c","src/codegen/context.rs":"42a4b71909c79cc1ab3a5ee6eb35aab1a52a092c7b8742cdf931cd7a9d2be9e5","src/codegen/control.rs":"3025ff2fa5c64b5c4a02394b054ad322979510a35a2561130ec7df0b8ef7256c","src/codegen/env.rs":"5f5e9ce8547cef135e65a00407cb0b21be3d2cfd303d00d2ca463d30a6ef952f","src/codegen/mod.rs":"472d6cee7fcdb6f346a74594e207f283bedd00f261f644b75d79fdb69151cf84","src/frame/mod.rs":"b63637e32c99ffae244f5e16b6a575ae27ebebc5837d862b58bb8ade238d7713","src/isa/aarch64/abi.rs":"bd0c46299a60523f9513b202e71c7a180bee2476ef42654f195efd1bbd220f99","src/isa/aarch64/address.rs":"1e876d8003fd6eab8cfff387a38942f781c2db497059bdec5582d022773bc180","src/isa/aarch64/asm.rs":"c923baba4a19904403898c26146c89b48b0b232238ce7ce8893481470bd6d0b4","src/isa/aarch64/masm.rs":"74808780dcf8c1204310ac84b49905e8807b4d8361af58593929008ee9095df7","src/isa/aarch64/mod.rs":"0f760a84f5cbe64d42aa5dbf08a2dac982a1216c028d478c7aae3d2df7dcda58","src/isa/aarch64/regs.rs":"6e33edfdc3011e6612346e4e8999a3b1739b8dd022845eb07673f7a19ac448c5","src/isa/mod.rs":"47141f61d181d1f4a9592f823fc2399c54e233612a9b00537ed7217f2cabc2f6","src/isa/reg.rs":"da6b570252d913d70a2b8ffa67745e83bd3438b26b74e45adf683a0596a5d14d","src/isa/x64/abi.rs":"3fce07b28af268fc38acb641e8788a8f4411e84856802f69a3bb4b2d41a7f3c6","src/isa/x64/address.rs":"38810e5806d7102fe1d9a7f34d131d55474341a6c43501bc087ffcf33ae3882d","src/isa/x64/asm.rs":"166c34fa3c680914db33a1d8adb877b1c2b24ef4997553c3018a38e644ed2fe6","src/isa/x64/masm.rs":"895e19c032f3c824a2036d7073a1f1103f987e7361b552114503d3f1877386a7","src/isa/x64/mod.rs":"3920db439c300e9078f3f6688238031954787287a42f5879d231251bdf0bf22b","src/isa/x64/regs.rs":"366b10c678934906d6f5bacd9dbb264406de5e259717fee1f7f7086b618f29b7","src/lib.rs":"d57d657ee8425b77292ed0a835c05b4047bc75f81ff79d61efd48a8d7f8ac69b","src/masm.rs":"684a5e49f4c9fbbcd5c4666543b25866f78827b30ce3de887a839da7432652ba","src/regalloc.rs":"14cce7251efd0536f5e1c1e925aeb2cefd4b6e017ae76b3681db2882a127589e","src/regset.rs":"020e076ee2f1f10cc4c7249a56f2a09d48b2097f38775e4a7431200d357db435","src/stack.rs":"f6d5c6370ff8d1d70c69867426e269f3df47db127e589c4b1204a2b9d96ace29","src/trampoline.rs":"bf6117a98e1457121d46ab161feb73c3d8a7a68b9f3cbd899887a4dbe811605f","src/visitor.rs":"4d6c97c66507b98b66b81a6b6b176c37115324df8f6fcb7b87a38e6c67cb9a8c"},"package":"9acd02b2090dc659c12bcea61a8b0a4fea3eb25c8385a7059c17e988979f8f0e"}

data/ext/cargo-vendor/winch-codegen-0.9.0/Cargo.toml

@@ -0,0 +1,62 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+name = "winch-codegen"
+version = "0.9.0"
+authors = ["The Winch Project Developers"]
+description = "Winch code generation library"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.anyhow]
+version = "1.0.22"
+
+[dependencies.cranelift-codegen]
+version = "0.98.0"
+
+[dependencies.gimli]
+version = "0.27.0"
+features = [
+    "read",
+    "std",
+]
+default-features = false
+
+[dependencies.regalloc2]
+version = "0.9.2"
+
+[dependencies.smallvec]
+version = "1.6.1"
+features = ["union"]
+
+[dependencies.target-lexicon]
+version = "0.12.3"
+features = [
+    "std",
+    "std",
+]
+default-features = false
+
+[dependencies.wasmparser]
+version = "0.107.0"
+
+[dependencies.wasmtime-environ]
+version = "=11.0.0"
+
+[features]
+all-arch = [
+    "x64",
+    "arm64",
+]
+arm64 = ["cranelift-codegen/arm64"]
+x64 = ["cranelift-codegen/x86"]

data/ext/cargo-vendor/winch-codegen-0.9.0/src/abi/mod.rs

@@ -0,0 +1,251 @@
+//! This module provides all the necessary building blocks for
+//! implementing ISA specific ABIs.
+//!
+//! # Default ABI
+//!
+//! Winch uses a default internal ABI, for all internal functions.
+//! This allows us to push the complexity of system ABI compliance to
+//! the trampolines (not yet implemented).  The default ABI treats all
+//! allocatable registers as caller saved, which means that (i) all
+//! register values in the Wasm value stack (which are normally
+//! referred to as "live"), must be saved onto the machine stack (ii)
+//! function prologues and epilogues don't store/restore other
+//! registers more than the non-allocatable ones (e.g. rsp/rbp in
+//! x86_64).
+//!
+//! The calling convention in the default ABI, uses registers to a
+//! certain fixed count for arguments and return values, and then the
+//! stack is used for all additional arguments.
+//!
+//! Generally the stack layout looks like:
+//! +-------------------------------+
+//! |                               |
+//! |                               |
+//! |         Stack Args            |
+//! |                               |
+//! |                               |
+//! +-------------------------------+----> SP @ function entry
+//! |         Ret addr              |
+//! +-------------------------------+
+//! |            SP                 |
+//! +-------------------------------+----> SP @ Function prologue
+//! |                               |
+//! |                               |
+//! |                               |
+//! |        Stack slots            |
+//! |        + `VMContext` slot     |
+//! |        + dynamic space        |
+//! |                               |
+//! |                               |
+//! |                               |
+//! +-------------------------------+----> SP @ callsite (after)
+//! |        alignment              |
+//! |        + arguments            |
+//! |                               | ----> Space allocated for calls
+//! |                               |
+use crate::isa::{reg::Reg, CallingConvention};
+use smallvec::SmallVec;
+use std::ops::{Add, BitAnd, Not, Sub};
+use wasmtime_environ::{WasmFuncType, WasmType};
+
+pub(crate) mod local;
+pub(crate) use local::*;
+
+/// Trait implemented by a specific ISA and used to provide
+/// information about alignment, parameter passing, usage of
+/// specific registers, etc.
+pub(crate) trait ABI {
+    /// The required stack alignment.
+    fn stack_align() -> u8;
+
+    /// The required stack alignment for calls.
+    fn call_stack_align() -> u8;
+
+    /// The offset to the argument base, relative to the frame pointer.
+    fn arg_base_offset() -> u8;
+
+    /// The offset to the return address, relative to the frame pointer.
+    fn ret_addr_offset() -> u8;
+
+    /// Construct the ABI-specific signature from a WebAssembly
+    /// function type.
+    fn sig(wasm_sig: &WasmFuncType, call_conv: &CallingConvention) -> ABISig;
+
+    /// Construct the ABI-specific result from a slice of
+    /// [`wasmtime_environ::WasmtType`].
+    fn result(returns: &[WasmType], call_conv: &CallingConvention) -> ABIResult;
+
+    /// Returns the number of bits in a word.
+    fn word_bits() -> u32;
+
+    /// Returns the number of bytes in a word.
+    fn word_bytes() -> u32 {
+        Self::word_bits() / 8
+    }
+
+    /// Returns the designated scratch register.
+    fn scratch_reg() -> Reg;
+
+    /// Returns the frame pointer register.
+    fn fp_reg() -> Reg;
+
+    /// Returns the stack pointer register.
+    fn sp_reg() -> Reg;
+
+    /// Returns the pinned register used to hold
+    /// the `VMContext`.
+    fn vmctx_reg() -> Reg;
+
+    /// Returns the callee-saved registers for the given
+    /// calling convention.
+    fn callee_saved_regs(call_conv: &CallingConvention) -> SmallVec<[Reg; 9]>;
+}
+
+/// ABI-specific representation of a function argument.
+#[derive(Debug)]
+pub(crate) enum ABIArg {
+    /// A register argument.
+    Reg {
+        /// Type of the argument.
+        ty: WasmType,
+        /// Register holding the argument.
+        reg: Reg,
+    },
+    /// A stack argument.
+    Stack {
+        /// The type of the argument.
+        ty: WasmType,
+        /// Offset of the argument relative to the frame pointer.
+        offset: u32,
+    },
+}
+
+impl ABIArg {
+    /// Allocate a new register abi arg.
+    pub fn reg(reg: Reg, ty: WasmType) -> Self {
+        Self::Reg { reg, ty }
+    }
+
+    /// Allocate a new stack abi arg.
+    pub fn stack_offset(offset: u32, ty: WasmType) -> Self {
+        Self::Stack { ty, offset }
+    }
+
+    /// Is this abi arg in a register.
+    pub fn is_reg(&self) -> bool {
+        match *self {
+            ABIArg::Reg { .. } => true,
+            _ => false,
+        }
+    }
+
+    /// Get the register associated to this arg.
+    pub fn get_reg(&self) -> Option<Reg> {
+        match *self {
+            ABIArg::Reg { reg, .. } => Some(reg),
+            _ => None,
+        }
+    }
+
+    /// Get the type associated to this arg.
+    pub fn ty(&self) -> WasmType {
+        match *self {
+            ABIArg::Reg { ty, .. } | ABIArg::Stack { ty, .. } => ty,
+        }
+    }
+}
+
+/// ABI-specific representation of the function result.
+#[derive(Copy, Clone, Debug)]
+pub(crate) enum ABIResult {
+    Reg {
+        /// Type of the result.
+        ty: Option<WasmType>,
+        /// Register to hold the result.
+        reg: Reg,
+    },
+}
+
+impl ABIResult {
+    /// Create a register ABI result.
+    pub fn reg(ty: Option<WasmType>, reg: Reg) -> Self {
+        Self::Reg { ty, reg }
+    }
+
+    /// Get the result reg.
+    pub fn result_reg(&self) -> Reg {
+        match self {
+            Self::Reg { reg, .. } => *reg,
+        }
+    }
+
+    /// Checks if the result is void.
+    pub fn is_void(&self) -> bool {
+        match self {
+            Self::Reg { ty, .. } => ty.is_none(),
+        }
+    }
+
+    /// Returns result's length.
+    pub fn len(&self) -> usize {
+        if self.is_void() {
+            0
+        } else {
+            1
+        }
+    }
+}
+
+pub(crate) type ABIParams = SmallVec<[ABIArg; 6]>;
+
+/// An ABI-specific representation of a function signature.
+pub(crate) struct ABISig {
+    /// Function parameters.
+    pub params: ABIParams,
+    /// Function result.
+    pub result: ABIResult,
+    /// Stack space needed for stack arguments.
+    pub stack_bytes: u32,
+}
+
+impl ABISig {
+    /// Create a new ABI signature.
+    pub fn new(params: ABIParams, result: ABIResult, stack_bytes: u32) -> Self {
+        Self {
+            params,
+            result,
+            stack_bytes,
+        }
+    }
+}
+
+/// Returns the size in bytes of a given WebAssembly type.
+pub(crate) fn ty_size(ty: &WasmType) -> u32 {
+    match *ty {
+        WasmType::I32 | WasmType::F32 => 4,
+        WasmType::I64 | WasmType::F64 => 8,
+        _ => panic!(),
+    }
+}
+
+/// Align a value up to the given power-of-two-alignment.
+// See https://sites.google.com/site/theoryofoperatingsystems/labs/malloc/align8
+pub(crate) fn align_to<N>(value: N, alignment: N) -> N
+where
+    N: Not<Output = N>
+        + BitAnd<N, Output = N>
+        + Add<N, Output = N>
+        + Sub<N, Output = N>
+        + From<u8>
+        + Copy,
+{
+    let alignment_mask = alignment - 1.into();
+    (value + alignment_mask) & !alignment_mask
+}
+
+/// Calculates the delta needed to adjust a function's frame plus some
+/// addend to a given alignment.
+pub(crate) fn calculate_frame_adjustment(frame_size: u32, addend: u32, alignment: u32) -> u32 {
+    let total = frame_size + addend;
+    (alignment - (total % alignment)) % alignment
+}

data/ext/cargo-vendor/winch-codegen-0.9.0/src/codegen/call.rs

@@ -0,0 +1,199 @@
+//! Function call emission.  For more details around the ABI and
+//! calling convention, see [ABI].
+use super::CodeGenContext;
+use crate::{
+    abi::{ABIArg, ABISig, ABI},
+    masm::{CalleeKind, MacroAssembler, OperandSize},
+    reg::Reg,
+};
+use wasmtime_environ::FuncIndex;
+
+/// All the information needed to emit a function call.
+pub(crate) struct FnCall<'a> {
+    /// The stack space consumed by the function call; that is,
+    /// the sum of:
+    ///
+    /// 1. The amount of stack space created by saving any live
+    ///    registers at the callsite.
+    /// 2. The amount of space used by any memory entries in the value
+    ///    stack present at the callsite, that will be used as
+    ///    arguments for the function call. Any memory values in the
+    ///    value stack that are needed as part of the function
+    ///    arguments, will be consumed by the function call (either by
+    ///    assigning those values to a register or by storing those
+    ///    values to a memory location if the callee argument is on
+    ///    the stack), so we track that stack space to reclaim it once
+    ///    the function call has ended. This could also be done in
+    ///    `assign_args` everytime a memory entry needs to be assigned
+    ///    to a particular location, but doing so, will incur in more
+    ///    instructions (e.g. a pop per argument that needs to be
+    ///    assigned); it's more efficient to track the space needed by
+    ///    those memory values and reclaim it at once.
+    ///
+    /// The machine stack throghout the function call is as follows:
+    /// ┌──────────────────────────────────────────────────┐
+    /// │                                                  │
+    /// │                  1                               │
+    /// │  Stack space created by any previous spills      │
+    /// │  from the value stack; and which memory values   │
+    /// │  are used as function arguments.                 │
+    /// │                                                  │
+    /// ├──────────────────────────────────────────────────┤ ---> The Wasm value stack at this point in time would look like:
+    /// │                                                  │      [ Reg | Reg | Mem(offset) | Mem(offset) ]
+    /// │                   2                              │
+    /// │   Stack space created by saving                  │
+    /// │   any live registers at the callsite.            │
+    /// │                                                  │
+    /// │                                                  │
+    /// ├─────────────────────────────────────────────────┬┤ ---> The Wasm value stack at this point in time would look like:
+    /// │                                                  │      [ Mem(offset) | Mem(offset) | Mem(offset) | Mem(offset) ]
+    /// │                                                  │      Assuming that the callee takes 4 arguments, we calculate
+    /// │                                                  │      2 spilled registers + 2 memory values; all of which will be used
+    /// │   Stack space allocated for                      │      as arguments to the call via `assign_args`, thus the memory they represent is
+    /// │   the callee function arguments in the stack;    │      is considered to be consumed by the call.
+    /// │   represented by `arg_stack_space`               │
+    /// │                                                  │
+    /// │                                                  │
+    /// │                                                  │
+    /// └──────────────────────────────────────────────────┘ ------> Stack pointer when emitting the call
+    ///
+    call_stack_space: u32,
+    /// The total stack space needed for the callee arguments on the
+    /// stack, including any adjustments to the function's frame and
+    /// aligned to to the required ABI alignment.
+    arg_stack_space: u32,
+    /// The ABI-specific signature of the callee.
+    abi_sig: &'a ABISig,
+}
+
+impl<'a> FnCall<'a> {
+    /// Allocate and setup a new function call.
+    ///
+    /// The setup process, will first save all the live registers in
+    /// the value stack, tracking down those spilled for the function
+    /// arguments(see comment below for more details) it will also
+    /// track all the memory entries consumed by the function
+    /// call. Then, it will calculate any adjustments needed to ensure
+    /// the alignment of the caller's frame.  It's important to note
+    /// that the order of operations in the setup is important, as we
+    /// want to calculate any adjustments to the caller's frame, after
+    /// having saved any live registers, so that we can account for
+    /// any pushes generated by register spilling.
+    pub fn new<M: MacroAssembler>(
+        callee_sig: &'a ABISig,
+        context: &mut CodeGenContext,
+        masm: &mut M,
+    ) -> Self {
+        let stack = &context.stack;
+        let arg_stack_space = callee_sig.stack_bytes;
+        let callee_params = &callee_sig.params;
+
+        let (spilled_regs, memory_values) = match callee_params.len() {
+            0 => {
+                let _ = context.spill_regs_and_count_memory_in(masm, ..);
+                (0, 0)
+            }
+            _ => {
+                // Here we perform a "spill" of the register entries
+                // in the Wasm value stack, we also count any memory
+                // values that will be used used as part of the callee
+                // arguments.  Saving the live registers is done by
+                // emitting push operations for every `Reg` entry in
+                // the Wasm value stack. We do this to be compliant
+                // with Winch's internal ABI, in which all registers
+                // are treated as caller-saved. For more details, see
+                // [ABI].
+                //
+                // The next few lines, partition the value stack into
+                // two sections:
+                // +------------------+--+--- (Stack top)
+                // |                  |  |
+                // |                  |  | 1. The top `n` elements, which are used for
+                // |                  |  |    function arguments; for which we save any
+                // |                  |  |    live registers, keeping track of the amount of registers
+                // +------------------+  |    saved plus the amount of memory values consumed by the function call;
+                // |                  |  |    with this information we can later reclaim the space used by the function call.
+                // |                  |  |
+                // +------------------+--+---
+                // |                  |  | 2. The rest of the items in the stack, for which
+                // |                  |  |    we only save any live registers.
+                // |                  |  |
+                // +------------------+  |
+                assert!(stack.len() >= callee_params.len());
+                let partition = stack.len() - callee_params.len();
+                let _ = context.spill_regs_and_count_memory_in(masm, 0..partition);
+                context.spill_regs_and_count_memory_in(masm, partition..)
+            }
+        };
+
+        Self {
+            abi_sig: &callee_sig,
+            arg_stack_space,
+            call_stack_space: (spilled_regs * <M::ABI as ABI>::word_bytes())
+                + (memory_values * <M::ABI as ABI>::word_bytes()),
+        }
+    }
+
+    /// Emit a direct function call, to a locally defined function.
+    pub fn direct<M: MacroAssembler>(
+        &self,
+        masm: &mut M,
+        context: &mut CodeGenContext,
+        callee: FuncIndex,
+    ) {
+        let reserved_stack = masm.call(self.arg_stack_space, |masm| {
+            self.assign_args(context, masm, <M::ABI as ABI>::scratch_reg());
+            CalleeKind::Direct(callee.as_u32())
+        });
+        self.post_call::<M>(masm, context, reserved_stack);
+    }
+
+    /// Emit an indirect function call, using a raw address.
+    pub fn indirect<M: MacroAssembler>(
+        &self,
+        masm: &mut M,
+        context: &mut CodeGenContext,
+        addr: M::Address,
+    ) {
+        let reserved_stack = masm.call(self.arg_stack_space, |masm| {
+            let scratch = <M::ABI as ABI>::scratch_reg();
+            self.assign_args(context, masm, scratch);
+            masm.load(addr, scratch, OperandSize::S64);
+            CalleeKind::Indirect(scratch)
+        });
+        self.post_call::<M>(masm, context, reserved_stack);
+    }
+
+    fn post_call<M: MacroAssembler>(&self, masm: &mut M, context: &mut CodeGenContext, size: u32) {
+        masm.free_stack(self.call_stack_space + size);
+        context.drop_last(self.abi_sig.params.len());
+        context.push_abi_results(&self.abi_sig.result, masm);
+    }
+
+    fn assign_args<M: MacroAssembler>(
+        &self,
+        context: &mut CodeGenContext,
+        masm: &mut M,
+        scratch: Reg,
+    ) {
+        let arg_count = self.abi_sig.params.len();
+        let stack = &context.stack;
+        let mut stack_values = stack.peekn(arg_count);
+        for arg in &self.abi_sig.params {
+            let val = stack_values
+                .next()
+                .unwrap_or_else(|| panic!("expected stack value for function argument"));
+            match &arg {
+                &ABIArg::Reg { ty, reg } => {
+                    context.move_val_to_reg(&val, *reg, masm, (*ty).into());
+                }
+                &ABIArg::Stack { ty, offset } => {
+                    let addr = masm.address_at_sp(*offset);
+                    let size: OperandSize = (*ty).into();
+                    context.move_val_to_reg(val, scratch, masm, size);
+                    masm.store(scratch.into(), addr, size);
+                }
+            }
+        }
+    }
+}