深入探索 Wasmtime：C++ 与 Rust Wasm 模块的双向通信与内存共享

// 伪代码示例 (实际代码在 wasm_host.cpp)
#include "wasmtime.hh" // 包含 Wasmtime C++ 头文件
#include <vector>
#include <fstream>
#include <stdexcept>

using namespace wasmtime;

// ... WasmHost 类的定义 ...

std::vector<uint8_t> WasmHost::readWasmFile() {
    std::ifstream file(wasm_path_, std::ios::binary | std::ios::ate);
    // ... 错误处理 ...
    std::streamsize size = file.tellg();
    file.seekg(0, std::ios::beg);
    std::vector<uint8_t> buffer(static_cast<size_t>(size));
    // ... 读取文件内容到 buffer ...
    return buffer;
}

void WasmHost::loadAndCompile() {
    std::vector<uint8_t> wasm_bytes = readWasmFile();
    std::cout << "[Host Setup] Compiling WASM module..." << std::endl;
    // engine_ 是 WasmHost 的成员变量，类型为 wasmtime::Engine
    Result<Module> module_res = Module::compile(engine_, wasm_bytes);
    if (!module_res) {
        throw std::runtime_error("Module compilation failed: " + module_res.err().message());
    }
    // module_ 也是 WasmHost 的成员变量，类型为 std::optional<wasmtime::Module>
    module_ = std::move(module_res.ok());
    std::cout << "[Host Setup] Module compiled successfully." << std::endl;
}

// 在 WasmHost 构造函数或初始化函数中调用 loadAndCompile()

// WasmHost 类成员变量
Engine engine_;
Store store_;

// WasmHost 构造函数
WasmHost::WasmHost(std::string wasm_path) : wasm_path_(std::move(wasm_path)),
                                            engine_(), // 创建默认 Engine
                                            store_(engine_) // 基于 Engine 创建 Store
{
    // ...
}

// WasmHost::setupWasi() 方法
void WasmHost::setupWasi() {
    // ... 检查是否已初始化或已配置 ...
    std::cout << "[Host Setup] Configuring WASI..." << std::endl;
    WasiConfig wasi;
    wasi.inherit_stdout(); // 让 Wasm 的 stdout 输出到宿主的 stdout
    wasi.inherit_stderr(); // 同上，stderr
    // store_ 是 WasmHost 的成员变量
    auto wasi_set_res = store_.context().set_wasi(std::move(wasi));
    if (!wasi_set_res) {
        throw std::runtime_error("Failed setting WASI config in store: " + wasi_set_res.err().message());
    }
    wasi_configured_ = true;
    std::cout << "[Host Setup] WASI configured for Store." << std::endl;
    // 还需要在 Linker 中定义 WASI 导入
    linkWasiImports();
}

// WasmHost::linkWasiImports() 方法
void WasmHost::linkWasiImports() {
    // ... 检查 WASI 是否配置 ...
    std::cout << "[Host Setup] Defining WASI imports in linker..." << std::endl;
    // linker_ 是 WasmHost 的成员变量，类型为 wasmtime::Linker
    auto linker_define_wasi_res = linker_.define_wasi();
     if (!linker_define_wasi_res) {
        throw std::runtime_error("Failed defining WASI imports in linker: " + linker_define_wasi_res.err().message());
    }
    std::cout << "[Host Setup] WASI imports defined." << std::endl;
}

// src/ffi.rs
#[link(wasm_import_module = "env")] // 模块名是 "env"
unsafe extern "C" {
    fn host_log_value(value: i32);
    fn host_get_shared_value() -> i32;
    fn host_set_shared_value(value: i32);
}

// host.cpp
#include <iostream>
#include <cstdint>

// 宿主状态
int32_t shared_host_value = 42;

// C++ 实现函数
void host_log_value_impl_target(int32_t value) {
    std::cout << "[Host Target] host_log_value called by WASM with value: " << value << std::endl;
}

int32_t host_get_shared_value_impl_target() {
    std::cout << "[Host Target] host_get_shared_value called by WASM. Returning: " << shared_host_value << std::endl;
    return shared_host_value;
}

void host_set_shared_value_impl_target(int32_t new_value) {
    std::cout << "[Host Target] host_set_shared_value called by WASM. Old host value: "
              << shared_host_value << ", New host value: " << new_value << std::endl;
    shared_host_value = new_value; // 修改宿主状态
}

// 在 WasmHost 类或主函数中，使用 Linker 注册这些函数
// (这是 WasmHost 类中的简化版包装函数)
template <typename FuncPtr>
void WasmHost::defineHostFunction(std::string_view module_name, std::string_view func_name, FuncPtr func_ptr)
{
    if (is_initialized_) {
        throw std::logic_error("Cannot define host functions after initialization.");
    }
    std::cout << "[Host Setup] Defining host function: " << module_name << "::" << func_name << "..." << std::endl;
    // linker_ 是 WasmHost 成员变量
    auto result = linker_.func_wrap(module_name, func_name, func_ptr);
    if (!result) {
        throw std::runtime_error("Failed to define host function '" + std::string(func_name) + "': " + result.err().message());
    }
}

// 在 main 函数中调用
host.defineHostFunction("env", "host_log_value", host_log_value_impl_target);
host.defineHostFunction("env", "host_get_shared_value", host_get_shared_value_impl_target);
host.defineHostFunction("env", "host_set_shared_value", host_set_shared_value_impl_target);

// WasmHost::instantiateModule() 方法
void WasmHost::instantiateModule() {
    // ... 检查 module_ 是否有效 ...
    std::cout << "[Host Setup] Instantiating module..." << std::endl;
    // store_ 是 WasmHost 成员变量
    TrapResult<Instance> instance_res = linker_.instantiate(store_.context(), module_.value());
    if (!instance_res) {
         // 处理实例化错误（可能是链接错误或 Wasm 启动陷阱）
        throw std::runtime_error("Module instantiation failed: " + instance_res.err().message());
    }
    // instance_ 是 WasmHost 成员, 类型 std::optional<wasmtime::Instance>
    instance_ = std::move(instance_res.ok());
    std::cout << "[Host Setup] Module instantiated successfully." << std::endl;
}

// WasmHost::getMemory() 方法
void WasmHost::getMemory() {
    // ... 检查 instance_ 是否有效 ...
    std::cout << "[Host Setup] Getting exported memory 'memory'..." << std::endl;
    // store_ 是 WasmHost 成员变量
    auto memory_export_opt = instance_.value().get(store_.context(), "memory");

    if (memory_export_opt && std::holds_alternative<Memory>(*memory_export_opt)) {
        // memory_ 是 WasmHost 成员, 类型 std::optional<wasmtime::Memory>
        memory_ = std::get<Memory>(*memory_export_opt);
        std::cout << "[Host Setup] Found exported memory. Size: "
                  << memory_.value().data(store_.context()).size() << " bytes." << std::endl;
    } else {
        std::cout << "[Host Setup] Export 'memory' not found or not a memory. Proceeding without memory access." << std::endl;
    }
}

// 获取内存的 Span<uint8_t>，它提供了对内存区域的视图
Span<uint8_t> WasmHost::getMemorySpan() {
    if (!is_initialized_ || !memory_.has_value()) {
        throw std::logic_error("Memory not available or host not initialized.");
    }
    return memory_.value().data(store_.context());
}

// src/lib.rs
mod ffi; // 声明 ffi 模块
pub(crate) mod core; // 声明内部的 core 模块

// 重新导出 FFI 层中需要被宿主调用的函数和类型
pub use ffi::{
    Point, get_plugin_shared_value_ptr, just_add, point_add, simple_add, trigger_host_calls,
};

// src/lib.rs (core 模块)
pub(crate) mod core {
    use crate::ffi::{ // 导入 FFI 层的安全包装器
        Point,
        get_shared_value_from_host,
        log_value_from_host,
        set_shared_value_in_host,
        // ...
    };

    pub fn perform_basic_add(left: u64, right: u64) -> u64 {
        println!("[WASM Core] perform_basic_add: {} + {}", left, right);
        left.wrapping_add(right) // 安全的加法
    }

    pub fn perform_host_calls_test(input_val: i32) {
        println!("[WASM Core] perform_host_calls_test with input: {}", input_val);
        // 调用宿主函数 (通过安全包装器)
        log_value_from_host(input_val * 2);
        let host_val = get_shared_value_from_host();
        set_shared_value_in_host(host_val + input_val + 5);
        // ...
    }
    // ... 其他核心逻辑函数 ...
}

// src/ffi.rs
#[repr(C)] // 关键：保证 C 兼容布局
#[derive(Debug, Copy, Clone, Default)]
pub struct Point {
    pub x: i32,
    pub y: i32,
}

// host.cpp
#pragma pack(push, 1) // 建议：确保与 Rust 端一致的紧凑布局
struct Point {
    int32_t x;
    int32_t y;
};
#pragma pack(pop)

// src/ffi.rs
static mut PLUGIN_SHARED_VALUE: i32 = 100; // Wasm 模块内部状态

// FFI 内部帮助函数，用于安全地读取（仍然需要 unsafe 块）
pub(crate) fn read_plugin_value_internal() -> i32 {
    unsafe { PLUGIN_SHARED_VALUE }
}

// 在 core 模块中使用
// use crate::ffi::read_plugin_value_internal;
// let val = read_plugin_value_internal();

// src/ffi.rs
#[no_mangle]
pub unsafe extern "C" fn get_plugin_shared_value_ptr() -> *mut i32 {
    // 注意：这里需要 `unsafe` fn 并且内部还需要 `unsafe` 块
    // 使用 `&raw mut` (较新 Rust 语法) 或直接转换来获取原始指针
    // let ptr = unsafe { &mut PLUGIN_SHARED_VALUE as *mut i32 };
    let ptr = { &raw mut PLUGIN_SHARED_VALUE as *mut i32 }; // 使用 &raw mut 避免 Miri 抱怨
    println!("[WASM FFI] get_plugin_shared_value_ptr() -> {:?}", ptr);
    ptr
}

// host.cpp (main 函数内, Test 1)
uint64_t arg1 = 15, arg2 = 27;
auto args = std::make_tuple(arg1, arg2);
std::cout << "[Host Main] Calling Wasm function 'just_add(" << arg1 << ", " << arg2 << ")'..." << std::endl;

// host 是 WasmHost 实例
// 类型推导：返回值是 tuple<u64>, 参数是 tuple<u64, u64>
auto result_tuple = host.callFunction<std::tuple<uint64_t>, std::tuple<uint64_t, uint64_t>>(
    "just_add", args);
// result_tuple 是 Result<std::tuple<uint64_t>, TrapError>
if (!result_tuple) { /* 错误处理 */ }
uint64_t result_val = std::get<0>(result_tuple.ok());
std::cout << "[Host Main] 'just_add' Result: " << result_val << std::endl;

// src/ffi.rs
#[no_mangle]
pub extern "C" fn just_add(left: u64, right: u64) -> u64 {
    println!("[WASM FFI] just_add called with: {} + {}", left, right);
    let result = crate::core::perform_basic_add(left, right); // 调用核心逻辑
    println!("[WASM FFI] just_add result: {}", result);
    result
}

// src/lib.rs::core
pub fn perform_basic_add(left: u64, right: u64) -> u64 {
    println!("[WASM Core] perform_basic_add: {} + {}", left, right);
    left.wrapping_add(right) // 使用安全加法
}

// host.cpp (main 函数内, Test 2)
int32_t trigger_arg = 7;
int32_t host_value_before = shared_host_value; // 记录调用前状态
std::cout << "[Host Main] Calling Wasm function 'trigger_host_calls(" << trigger_arg << ")'..." << std::endl;

// host.callFunctionVoid 封装了调用无返回值 Wasm 函数的逻辑
// 参数是 tuple<i32>
host.callFunctionVoid<std::tuple<int32_t>>(
    "trigger_host_calls", std::make_tuple(trigger_arg));

std::cout << "[Host Main] Returned from 'trigger_host_calls'." << std::endl;
// 检查调用后宿主状态是否被 Wasm 修改
// ... 比较 shared_host_value 与预期值 ...

// src/ffi.rs - 导入声明和安全包装 (前面已展示)

// src/ffi.rs - 导出触发函数
#[no_mangle]
pub extern "C" fn trigger_host_calls(input_val: i32) {
    println!("[WASM FFI] trigger_host_calls called with input: {}", input_val);
    crate::core::perform_host_calls_test(input_val); // 调用核心逻辑
    println!("[WASM FFI] trigger_host_calls finished.");
}

// src/lib.rs::core - 核心逻辑，调用宿主函数
pub fn perform_host_calls_test(input_val: i32) {
    println!("[WASM Core] perform_host_calls_test with input: {}", input_val);

    // 1. 调用 host_log_value
    log_value_from_host(input_val * 2);

    // 2. 调用 host_get_shared_value
    let host_val = get_shared_value_from_host();
    println!("[WASM Core] Received value from host: {}", host_val);

    // 3. 调用 host_set_shared_value (修改宿主状态)
    let new_host_val = host_val.wrapping_add(input_val).wrapping_add(5);
    set_shared_value_in_host(new_host_val);
    // ...
}

// host.cpp (main 函数内, Test 3)
const size_t point_size = sizeof(Point);
const int32_t offset_p1 = 2048; // 示例偏移量
const int32_t offset_p2 = offset_p1 + point_size;
const int32_t offset_result = offset_p2 + point_size;

Point host_p1 = {100, 200};
Point host_p2 = {30, 70};

std::cout << "[Host Main] Writing points to WASM memory..." << std::endl;
// host.writeMemory 封装了获取 Span 和 memcpy 的逻辑
host.writeMemory(offset_p1, host_p1); // 将 host_p1 写入 Wasm 内存
host.writeMemory(offset_p2, host_p2); // 将 host_p2 写入 Wasm 内存

std::cout << "[Host Main] Calling Wasm function 'point_add' with offsets..." << std::endl;
// 参数是偏移量 (i32)，代表指针
auto point_add_args = std::make_tuple(offset_result, offset_p1, offset_p2);
host.callFunctionVoid<std::tuple<int32_t, int32_t, int32_t>>("point_add", point_add_args);

std::cout << "[Host Main] Reading result struct from WASM memory..." << std::endl;
// host.readMemory 封装了获取 Span 和 memcpy 的逻辑
Point result_point = host.readMemory<Point>(offset_result); // 从 Wasm 内存读取结果
std::cout << "[Host Main] 'point_add' Result read from memory: { x: " << result_point.x
          << ", y: " << result_point.y << " }" << std::endl;
// ... 验证结果 ...

// WasmHost 类中的 writeMemory/readMemory 简化实现：
template <typename T>
void WasmHost::writeMemory(int32_t offset, const T& data) {
    auto memory_span = getMemorySpan();
    size_t data_size = sizeof(T);
    if (offset < 0 || static_cast<size_t>(offset) + data_size > memory_span.size()) {
        throw std::out_of_range("Memory write out of bounds");
    }
    std::memcpy(memory_span.data() + offset, &data, data_size);
}

template <typename T>
T WasmHost::readMemory(int32_t offset) {
    auto memory_span = getMemorySpan();
    size_t data_size = sizeof(T);
     if (offset < 0 || static_cast<size_t>(offset) + data_size > memory_span.size()) {
        throw std::out_of_range("Memory read out of bounds");
    }
    T result;
    std::memcpy(&result, memory_span.data() + offset, data_size);
    return result;
}

// src/ffi.rs - Point struct 定义 (前面已展示)

// src/ffi.rs - 导出 point_add 函数
#[no_mangle]
pub extern "C" fn point_add(result_ptr: *mut Point, p1_ptr: *const Point, p2_ptr: *const Point) {
    println!("[WASM FFI] point_add called with pointers...");
    unsafe { // 必须使用 unsafe 来解引用原始指针
        if result_ptr.is_null() || p1_ptr.is_null() || p2_ptr.is_null() {
            println!("[WASM FFI] Error: Received null pointer.");
            return;
        }
        // 解引用输入指针，读取数据
        let p1 = *p1_ptr;
        let p2 = *p2_ptr;
        // 调用核心逻辑计算
        let result = crate::core::add_points(p1, p2);
        // 解引用输出指针，写入结果
        *result_ptr = result;
        println!("[WASM FFI] Wrote result to address {:?}", result_ptr);
    }
}

// src/lib.rs::core - 核心加法逻辑
pub fn add_points(p1: Point, p2: Point) -> Point {
    println!("[WASM Core] add_points called with p1: {:?}, p2: {:?}", p1, p2);
    Point {
        x: p1.x.wrapping_add(p2.x),
        y: p1.y.wrapping_add(p2.y),
    }
}

// host.cpp (main 函数内, Test 4)
int32_t plugin_value_offset = -1;
// ...

std::cout << "[Host Main] Calling Wasm 'get_plugin_shared_value_ptr'..." << std::endl;
// getPluginDataOffset 封装了调用 Wasm 函数获取偏移量的逻辑
plugin_value_offset = host.getPluginDataOffset("get_plugin_shared_value_ptr");
std::cout << "[Host Main] Received offset: " << plugin_value_offset << std::endl;

if (plugin_value_offset > 0) { // 基本有效性检查
    // 读取 Wasm 状态
    int32_t value_from_plugin_before = host.readMemory<int32_t>(plugin_value_offset);
    std::cout << "[Host Main] Value read from plugin: " << value_from_plugin_before << std::endl;

    // 写入新值到 Wasm 状态
    const int32_t new_value_for_plugin = 777;
    std::cout << "[Host Main] Writing new value (" << new_value_for_plugin << ") to plugin state..." << std::endl;
    host.writeMemory(plugin_value_offset, new_value_for_plugin);

    // 再次读取验证
    int32_t value_from_plugin_after = host.readMemory<int32_t>(plugin_value_offset);
    std::cout << "[Host Main] Value read after host write: " << value_from_plugin_after << std::endl;
    // ... 验证 value_from_plugin_after == new_value_for_plugin ...
}

// WasmHost::getPluginDataOffset 实现
int32_t WasmHost::getPluginDataOffset(std::string_view func_name) {
    std::cout << "[Host] Getting plugin data offset via '" << func_name << "'..." << std::endl;
    // Wasm 函数无参数，返回 i32 (偏移量)
    auto result_tuple = callFunction<std::tuple<int32_t>>(func_name);
    if (!result_tuple) { /* 错误处理 */ return -1; }
    int32_t offset = std::get<0>(result_tuple.ok());
    std::cout << "[Host] Received offset from plugin: " << offset << std::endl;
    return offset;
}

// src/ffi.rs
static mut PLUGIN_SHARED_VALUE: i32 = 100;

#[no_mangle]
pub unsafe extern "C" fn get_plugin_shared_value_ptr() -> *mut i32 {
    let ptr = { &raw mut PLUGIN_SHARED_VALUE as *mut i32 };
    println!("[WASM FFI] get_plugin_shared_value_ptr() -> {:?}", ptr);
    ptr
}

// host.cpp (main 函数内, Test 5, 假设 plugin_value_offset > 0)
std::cout << "[Host Main] Calling Wasm 'simple_add' to verify internal state..." << std::endl;
// 调用一个 Wasm 函数，让它有机会读取并打印自己的状态
auto args = std::make_tuple(1ULL, 1ULL);
host.callFunction<std::tuple<uint64_t>, std::tuple<uint64_t, uint64_t>>(
    "simple_add", args);
std::cout << "[Host Main] Returned from 'simple_add'. Check WASM output above." << std::endl;

// src/ffi.rs
#[no_mangle]
pub extern "C" fn simple_add(left: u64, right: u64) -> u64 {
    println!("[WASM FFI] simple_add (verification step) called...");
    crate::core::perform_simple_add_and_read_internal_state(left, right)
}

// 内部帮助函数，读取 static mut (需要 unsafe)
pub(crate) fn read_plugin_value_internal() -> i32 {
    unsafe { PLUGIN_SHARED_VALUE }
}

// src/lib.rs::core
pub fn perform_simple_add_and_read_internal_state(left: u64, right: u64) -> u64 {
    // 读取并打印自己的内部状态
    let current_plugin_val = read_plugin_value_internal(); // 调用 FFI 辅助函数
    println!(
        "[WASM Core] Current plugin's internal shared value: {}", // 期望这里打印 777
        current_plugin_val
    );

    println!("[WASM Core] Performing simple add: {} + {}", left, right);
    // ... 执行原本的加法逻辑 ...
    left + right // 假设简单返回
}