5.3 WASM：以 Rust 寫一個 WebAssembly 執行器#

pub struct Instance {
    pub memory: Vec<u8>,          // 線性記憶體：唯一的資料空間
    pub globals: Vec<Value>,      // 全域變數
    pub table: Vec<Option<u32>>,  // 間接呼叫表
    pub stack: Vec<ValType>,      // 運算元堆疊
    pub frames: Vec<WasmFrame>,
}

// src/wasm.rs — 簡化的 WASM 執行器
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum ValType { I32, I64 }

#[derive(Debug, Clone, Copy)]
pub enum WasmVal { I32(i32), I64(i64) }

/// 簡化後的指令集（真實 WASM 的子集）
#[derive(Debug, Clone, Copy)]
pub enum WasmInstr {
    I32Const(i32),
    I32Add,
    I32Sub,
    I32Mul,
    LocalGet(u32),
    LocalSet(u32),
    Call(u32),          // 函式索引
    End,                 // 函式結尾
}

pub struct WasmFunc {
    pub params: Vec<ValType>,
    pub results: Vec<ValType>,
    pub locals: Vec<ValType>,
    pub code: Vec<WasmInstr>,
}

pub struct WasmModule {
    pub funcs: Vec<WasmFunc>,
    pub memory_pages: u32,       // 1 頁 = 64KiB
}

pub fn validate(module: &WasmModule) -> Result<(), String> {
    for (i, func) in module.funcs.iter().enumerate() {
        let mut stack: Vec<ValType> = func.params.clone();
        for instr in &func.code {
            match instr {
                WasmInstr::I32Const(_) => stack.push(ValType::I32),
                WasmInstr::LocalGet(idx) => {
                    let t = func.locals.get(*idx as usize)
                        .or_else(|| func.params.get(*idx as usize))
                        .ok_or(format!("func {i}: local {idx} out of range"))?;
                    stack.push(*t);
                }
                WasmInstr::I32Add | WasmInstr::I32Sub | WasmInstr::I32Mul => {
                    let b = stack.pop().ok_or(format!("func {i}: stack underflow"))?;
                    let a = stack.pop().ok_or(format!("func {i}: stack underflow"))?;
                    if a != ValType::I32 || b != ValType::I32 {
                        return Err(format!("func {i}: i32 op requires i32 operands"));
                    }
                    stack.push(ValType::I32);
                }
                WasmInstr::Call(f) => {
                    let callee = module.funcs.get(*f as usize)
                        .ok_or(format!("func {i}: call to unknown func {f}"))?;
                    // 檢查參數型別匹配
                    if stack.len() < callee.params.len() {
                        return Err(format!("func {i}: not enough args for call {f}"));
                    }
                    for t in callee.params.iter().rev() {
                        let got = stack.pop().unwrap();
                        if got != *t { return Err(format!("func {i}: arg type mismatch")); }
                    }
                    for t in &callee.results { stack.push(*t); }
                }
                WasmInstr::End => { /* 檢查回傳型別 */ }
            }
        }
    }
    Ok(())
}

pub struct WasmRuntime {
    pub module: WasmModule,
    pub memory: Vec<u8>,
}

impl WasmRuntime {
    pub fn instantiate(module: WasmModule) -> Result<Self, String> {
        validate(&module)?;
        Ok(WasmRuntime {
            memory: vec![0; module.memory_pages as usize * 65536],
            module,
        })
    }

    pub fn invoke(&mut self, func_idx: u32, args: &[WasmVal]) -> Result<WasmVal, String> {
        let func = self.module.funcs.get(func_idx as usize)
            .ok_or("unknown function")?
            .clone();

        let mut stack: Vec<WasmVal> = args.to_vec();
        let mut locals: Vec<WasmVal> = func.locals.iter()
            .map(|t| match t { ValType::I32 => WasmVal::I32(0), ValType::I64 => WasmVal::I64(0) })
            .collect();
        locals.extend(args.iter().cloned());  // 簡化：參數也算 local

        let mut pc = 0;
        while pc < func.code.len() {
            match &func.code[pc] {
                WasmInstr::I32Const(n) => stack.push(WasmVal::I32(*n)),
                WasmInstr::I32Add => self.binop_i32(&mut stack, |a, b| a.wrapping_add(b))?,
                WasmInstr::I32Mul => self.binop_i32(&mut stack, |a, b| a.wrapping_mul(b))?,
                WasmInstr::LocalGet(i) => {
                    let v = *locals.get(*i as usize).ok_or("local out of range")?;
                    stack.push(v);
                }
                WasmInstr::LocalSet(i) => {
                    let v = stack.pop().ok_or("stack underflow")?;
                    let slot = locals.get_mut(*i as usize).ok_or("local out of range")?;
                    *slot = v;
                }
                WasmInstr::End => break,
                WasmInstr::Call(_) => return Err("call not supported in this subset".into()),
            }
            pc += 1;
        }
        stack.pop().ok_or_else(|| "no return value".into())
    }

    fn binop_i32(&mut self, stack: &mut Vec<WasmVal>, f: fn(i32, i32) -> i32) -> Result<(), String> {
        let b = match stack.pop() { Some(WasmVal::I32(v)) => v, _ => return Err("type error".into()) };
        let a = match stack.pop() { Some(WasmVal::I32(v)) => v, _ => return Err("type error".into()) };
        stack.push(WasmVal::I32(f(a, b)));
        Ok(())
    }
}

impl WasmRuntime {
    pub fn load_i32(&self, addr: u32) -> Result<i32, String> {
        let a = addr as usize;
        if a + 4 > self.memory.len() {
            return Err(format!("out of bounds: {addr:#x} + 4 > {}", self.memory.len()));
        }
        Ok(i32::from_le_bytes(self.memory[a..a+4].try_into().unwrap()))
    }

    pub fn store_i32(&mut self, addr: u32, val: i32) -> Result<(), String> {
        let a = addr as usize;
        if a + 4 > self.memory.len() {
            return Err(format!("out of bounds: {addr:#x} + 4 > {}", self.memory.len()));
        }
        self.memory[a..a+4].copy_from_slice(&val.to_le_bytes());
        Ok(())
    }
}