Rust WASM运行时wasmtime的C API宏库wasmtime-c-api-macros使用指南：实现高效WebAssembly接口绑定

安装

在项目目录中运行以下Cargo命令：

cargo add wasmtime-c-api-macros

或者在Cargo.toml中添加以下行：

wasmtime-c-api-macros = "34.0.2"

使用示例

下面是一个完整的示例，展示如何使用wasmtime-c-api-macros来绑定WebAssembly函数：

use wasmtime_c_api_macros::wasmtime_c_api;

// 定义一个Rust函数，将被暴露给WebAssembly
#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}

// 使用wasmtime_c_api宏生成C API绑定
wasmtime_c_api! {
    // 定义模块名
    module "math" {
        // 暴露add函数给WebAssembly
        export "add" fn add(a: i32, b: i32) -> i32;
    }
}

fn main() {
    // 初始化wasmtime引擎
    let engine = wasmtime::Engine::default();
    let mut store = wasmtime::Store::new(&engine, ());
    
    // 使用生成的绑定创建模块
    let module = wasmtime::Module::new(&engine, wasmtime_c_api::math::MODULE).unwrap();
    
    // 实例化模块
    let instance = wasmtime::Instance::new(&mut store, &module, &[]).unwrap();
    
    // 获取add函数并调用
    let add = instance.get_typed_func::<(i32, i32), i32>(&mut store, "add").unwrap();
    let result = add.call(&mut store, (2, 3)).unwrap();
    
    println!("2 + 3 = {}", result); // 输出: 2 + 3 = 5
}

高级用法

wasmtime-c-api-macros还支持更复杂的绑定场景：

use wasmtime_c_api_macros::wasmtime_c_api;

// 定义复杂数据结构
#[repr(C)]
pub struct Point {
    x: f32,
    y: f32,
}

// 实现复杂函数
#[no_mangle]
pub extern "C" fn distance(p1: Point, p2: Point) -> f32 {
    let dx = p1.x - p2.x;
    let dy = p1.y - p2.y;
    (dx * dx + dy * dy).sqrt()
}

wasmtime_c_api! {
    module "geometry" {
        // 定义结构体类型
        type Point {
            x: f32,
            y: f32,
        }
        
        // 暴露复杂函数
        export "distance" fn distance(p1: Point, p2: Point) -> f32;
    }
}

// 使用方式与简单示例类似，但可以处理复杂数据结构

完整示例demo

下面是一个结合了基础用法和高级用法的完整示例：

use wasmtime_c_api_macros::wasmtime_c_api;

// 基础数学运算
#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}

// 几何运算
#[repr(C)]
pub struct Point {
    x: f32,
    y: f32,
}

#[no_mangle]
pub extern "C" fn distance(p1: Point, p2: Point) -> f32 {
    let dx = p1.x - p2.x;
    let dy = p1.y - p2.y;
    (dx * dx + dy * dy).sqrt()
}

// 生成所有绑定
wasmtime_c_api! {
    module "math" {
        export "add" fn add(a: i32, b: i32) -> i32;
    }
    
    module "geometry" {
        type Point {
            x: f32,
            y: f32,
        }
        export "distance" fn distance(p1: Point, p2: Point) -> f32;
    }
}

fn main() {
    let engine = wasmtime::Engine::default();
    let mut store = wasmtime::Store::new(&engine, ());
    
    // 测试数学模块
    let math_module = wasmtime::Module::new(&engine, wasmtime_c_api::math::MODULE).unwrap();
    let math_instance = wasmtime::Instance::new(&mut store, &math_module, &[]).unwrap();
    let add_func = math_instance.get_typed_func::<(i32, i32), i32>(&mut store, "add").unwrap();
    let result = add_func.call(&mut store, (5, 7)).unwrap();
    println!("5 + 7 = {}", result);
    
    // 测试几何模块
    let geo_module = wasmtime::Module::new(&engine, wasmtime_c_api::geometry::MODULE).unwrap();
    let geo_instance = wasmtime::Instance::new(&mut store, &geo_module, &[]).unwrap();
    let distance_func = geo_instance.get_typed_func::<(Point, Point), f32>(&mut store, "distance").unwrap();
    
    let p1 = Point { x: 1.0, y: 2.0 };
    let p2 = Point { x: 4.0, y: 6.0 };
    let dist = distance_func.call(&mut store, (p1, p2)).unwrap();
    println!("两点之间的距离: {}", dist);
}

许可证

Apache-2.0 WITH LLVM-exception