wasmer_compiler_cranelift/trampoline/
dynamic_function.rs

1// This file contains code from external sources.
2// Attributions: https://github.com/wasmerio/wasmer/blob/main/docs/ATTRIBUTIONS.md
3
4//! A trampoline generator for calling dynamic host functions from Wasm.
5
6use crate::{
7    CraneliftCallbacks, abi,
8    translator::{compiled_function_unwind_info, signature_to_cranelift_ir, type_to_irtype},
9};
10use cranelift_codegen::{
11    Context,
12    ir::{self, Function, InstBuilder, StackSlotData, StackSlotKind, UserFuncName},
13    isa::TargetIsa,
14};
15use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
16use std::{cmp, mem};
17use target_lexicon::Architecture;
18use wasmer_compiler::{misc::CompiledKind, types::function::FunctionBody};
19use wasmer_types::{CompileError, FunctionType, VMOffsets};
20
21/// Create a trampoline for invoking a WebAssembly function.
22#[allow(clippy::too_many_arguments)]
23pub fn make_trampoline_dynamic_function(
24    callbacks: &Option<CraneliftCallbacks>,
25    isa: &dyn TargetIsa,
26    arch: Architecture,
27    offsets: &VMOffsets,
28    fn_builder_ctx: &mut FunctionBuilderContext,
29    kind: &CompiledKind,
30    func_type: &FunctionType,
31    module_hash: &Option<String>,
32) -> Result<FunctionBody, CompileError> {
33    let pointer_type = isa.pointer_type();
34    let frontend_config = isa.frontend_config();
35    let signature = signature_to_cranelift_ir(func_type, frontend_config, arch);
36    let mut stub_sig = ir::Signature::new(frontend_config.default_call_conv);
37    // Add the caller `vmctx` parameter.
38    stub_sig.params.push(ir::AbiParam::special(
39        pointer_type,
40        ir::ArgumentPurpose::VMContext,
41    ));
42
43    // Add the `values_vec` parameter.
44    stub_sig.params.push(ir::AbiParam::new(pointer_type));
45
46    // Compute the size of the values vector. The vmctx and caller vmctx are passed separately.
47    let value_size = mem::size_of::<u128>();
48    let values_vec_len =
49        (value_size * cmp::max(func_type.params().len(), func_type.results().len())) as u32;
50
51    let mut context = Context::new();
52    context.func = Function::with_name_signature(UserFuncName::user(0, 0), signature.clone());
53
54    let ss = context.func.create_sized_stack_slot(StackSlotData::new(
55        StackSlotKind::ExplicitSlot,
56        values_vec_len,
57        0,
58    ));
59
60    {
61        let mut builder = FunctionBuilder::new(&mut context.func, fn_builder_ctx);
62        let block0 = builder.create_block();
63
64        builder.append_block_params_for_function_params(block0);
65        builder.switch_to_block(block0);
66        builder.seal_block(block0);
67
68        let values_vec_ptr_val = builder.ins().stack_addr(pointer_type, ss, 0);
69        let mflags = ir::MemFlagsData::trusted();
70        // Copy only normal WebAssembly arguments; special ABI arguments are separate.
71        let mut wasm_param = 0usize;
72        let mut vmctx_ptr_val = None;
73        let mut sret_ptr = None;
74        for (i, param) in signature.params.iter().enumerate() {
75            let val = builder.func.dfg.block_params(block0)[i];
76            match param.purpose {
77                ir::ArgumentPurpose::Normal => {
78                    builder.ins().store(
79                        mflags,
80                        val,
81                        values_vec_ptr_val,
82                        (wasm_param * value_size) as i32,
83                    );
84                    wasm_param += 1;
85                }
86                ir::ArgumentPurpose::VMContext => vmctx_ptr_val = Some(val),
87                ir::ArgumentPurpose::StructReturn => sret_ptr = Some(val),
88                _ => unreachable!("unexpected WebAssembly ABI parameter"),
89            }
90        }
91
92        let vmctx_ptr_val = vmctx_ptr_val.expect("WebAssembly signature has vmctx");
93        let callee_args = vec![vmctx_ptr_val, values_vec_ptr_val];
94
95        let new_sig = builder.import_signature(stub_sig);
96
97        let mem_flags = ir::MemFlagsData::trusted();
98        let callee_value = builder.ins().load(
99            pointer_type,
100            mem_flags,
101            vmctx_ptr_val,
102            offsets.vmdynamicfunction_import_context_address() as i32,
103        );
104
105        builder
106            .ins()
107            .call_indirect(new_sig, callee_value, &callee_args);
108
109        let mflags = ir::MemFlagsData::trusted();
110        let mut results = Vec::new();
111        for (i, &ty) in func_type.results().iter().enumerate() {
112            let load = builder.ins().load(
113                type_to_irtype(ty, frontend_config).unwrap(),
114                mflags,
115                values_vec_ptr_val,
116                (i * value_size) as i32,
117            );
118            results.push(load);
119        }
120        let return_abi = abi::classify_returns(arch, func_type.results());
121        match &return_abi {
122            wasmer_compiler::abi::ReturnAbi::Sret(types) => {
123                let layout = abi::return_area_layout(types);
124                abi::store_sret(
125                    &mut builder,
126                    sret_ptr.expect("sret signature has return pointer"),
127                    &layout,
128                    &results,
129                );
130                builder.ins().return_(&[]);
131            }
132            _ => {
133                let packed = abi::pack_register_returns(&mut builder, &return_abi, &results);
134                builder.ins().return_(&packed);
135            }
136        }
137        builder.finalize(frontend_config)
138    }
139
140    if let Some(callbacks) = callbacks.as_ref() {
141        callbacks.preopt_ir(
142            kind,
143            module_hash,
144            context.func.display().to_string().as_bytes(),
145        );
146    }
147
148    let mut code_buf = Vec::new();
149    let mut ctrl_plane = Default::default();
150    let compiled = context
151        .compile(isa, &mut ctrl_plane)
152        .map_err(|error| CompileError::Codegen(error.inner.to_string()))?;
153    code_buf.extend_from_slice(compiled.code_buffer());
154
155    if let Some(callbacks) = callbacks.as_ref() {
156        callbacks.obj_memory_buffer(kind, module_hash, &code_buf);
157        callbacks.asm_memory_buffer(kind, module_hash, arch, &code_buf)?;
158    }
159
160    let unwind_info = compiled_function_unwind_info(isa, &context)?.maybe_into_to_windows_unwind();
161
162    Ok(FunctionBody {
163        body: code_buf,
164        unwind_info,
165    })
166}
wasmer_compiler_cranelift/trampoline/dynamic_function.rs

wasmer_compiler_cranelift/trampoline/
dynamic_function.rs
