wasmer_compiler_cranelift/trampoline/
function_call.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 Wasm functions easily.
5//!
6//! That way, you can start calling Wasm functions doing things like:
7//! ```ignore
8//! let my_func = instance.exports.get("func");
9//! my_func.call([1, 2])
10//! ```
11use crate::{
12    CraneliftCallbacks, abi,
13    translator::{compiled_function_unwind_info, signature_to_cranelift_ir},
14};
15use cranelift_codegen::{
16    Context,
17    ir::{self, InstBuilder},
18    isa::TargetIsa,
19};
20use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
21use std::mem;
22use target_lexicon::Architecture;
23use wasmer_compiler::{misc::CompiledKind, types::function::FunctionBody};
24use wasmer_types::{CompileError, FunctionType};
25
26/// Create a trampoline for invoking a WebAssembly function.
27pub fn make_trampoline_function_call(
28    callbacks: &Option<CraneliftCallbacks>,
29    isa: &dyn TargetIsa,
30    arch: Architecture,
31    fn_builder_ctx: &mut FunctionBuilderContext,
32    kind: &CompiledKind,
33    func_type: &FunctionType,
34    module_hash: &Option<String>,
35) -> Result<FunctionBody, CompileError> {
36    let pointer_type = isa.pointer_type();
37    let frontend_config = isa.frontend_config();
38    let signature = signature_to_cranelift_ir(func_type, frontend_config, arch);
39    let mut wrapper_sig = ir::Signature::new(frontend_config.default_call_conv);
40
41    // Add the callee `vmctx` parameter.
42    wrapper_sig.params.push(ir::AbiParam::special(
43        pointer_type,
44        ir::ArgumentPurpose::VMContext,
45    ));
46
47    // Add the `callee_address` parameter.
48    wrapper_sig.params.push(ir::AbiParam::new(pointer_type));
49
50    // Add the `values_vec` parameter.
51    wrapper_sig.params.push(ir::AbiParam::new(pointer_type));
52
53    let mut context = Context::new();
54    context.func = ir::Function::with_name_signature(ir::UserFuncName::user(0, 0), wrapper_sig);
55
56    let value_size = mem::size_of::<u128>();
57    {
58        let mut builder = FunctionBuilder::new(&mut context.func, fn_builder_ctx);
59        let block0 = builder.create_block();
60
61        builder.append_block_params_for_function_params(block0);
62        builder.switch_to_block(block0);
63        builder.seal_block(block0);
64
65        let (vmctx_ptr_val, callee_value, values_vec_ptr_val) = {
66            let params = builder.func.dfg.block_params(block0);
67            (params[0], params[1], params[2])
68        };
69
70        // Load the argument values out of `values_vec` and add special ABI arguments.
71        let return_abi = abi::classify_returns(arch, func_type.results());
72        let sret = match &return_abi {
73            wasmer_compiler::abi::ReturnAbi::Sret(types) => Some(abi::allocate_return_area(
74                &mut builder,
75                types,
76                frontend_config,
77            )),
78            _ => None,
79        };
80        let mflags = ir::MemFlagsData::trusted();
81        let mut wasm_param = 0usize;
82        let callee_args = signature
83            .params
84            .iter()
85            .map(|r| match r.purpose {
86                ir::ArgumentPurpose::StructReturn => sret.as_ref().unwrap().0,
87                ir::ArgumentPurpose::VMContext => vmctx_ptr_val,
88                ir::ArgumentPurpose::Normal => {
89                    let value = builder.ins().load(
90                        r.value_type,
91                        mflags,
92                        values_vec_ptr_val,
93                        (wasm_param * value_size) as i32,
94                    );
95                    wasm_param += 1;
96                    value
97                }
98                _ => unreachable!("unexpected WebAssembly ABI parameter"),
99            })
100            .collect::<Vec<_>>();
101
102        let new_sig = builder.import_signature(signature);
103
104        let call = builder
105            .ins()
106            .call_indirect(new_sig, callee_value, &callee_args);
107
108        let carriers = builder.func.dfg.inst_results(call).to_vec();
109        let results = match (&return_abi, sret) {
110            (wasmer_compiler::abi::ReturnAbi::Sret(types), Some((ptr, layout))) => {
111                abi::load_sret(&mut builder, ptr, &layout, types, frontend_config)
112            }
113            _ => {
114                abi::unpack_register_returns(&mut builder, &return_abi, &carriers, frontend_config)
115            }
116        };
117
118        // Store the return values into `values_vec`.
119        let mflags = ir::MemFlagsData::trusted();
120        for (i, r) in results.iter().enumerate() {
121            builder
122                .ins()
123                .store(mflags, *r, values_vec_ptr_val, (i * value_size) as i32);
124        }
125
126        builder.ins().return_(&[]);
127        builder.finalize(frontend_config)
128    }
129
130    if let Some(callbacks) = callbacks.as_ref() {
131        callbacks.preopt_ir(
132            kind,
133            module_hash,
134            context.func.display().to_string().as_bytes(),
135        );
136    }
137
138    let mut code_buf = Vec::new();
139    let mut ctrl_plane = Default::default();
140    let compiled = context
141        .compile(isa, &mut ctrl_plane)
142        .map_err(|error| CompileError::Codegen(error.inner.to_string()))?;
143    code_buf.extend_from_slice(compiled.code_buffer());
144
145    if let Some(callbacks) = callbacks.as_ref() {
146        callbacks.obj_memory_buffer(kind, module_hash, &code_buf);
147        callbacks.asm_memory_buffer(kind, module_hash, arch, &code_buf)?;
148    }
149
150    let unwind_info = compiled_function_unwind_info(isa, &context)?.maybe_into_to_windows_unwind();
151
152    Ok(FunctionBody {
153        body: code_buf,
154        unwind_info,
155    })
156}
wasmer_compiler_cranelift/trampoline/function_call.rs

wasmer_compiler_cranelift/trampoline/
function_call.rs
