[TOC]
实现方案
如果要实现一个自己的函数，有两种实现方式，一种是在虚拟机内部直接以内置指令的方式实现，如add函数等，但是这种方式需要修改编译器，并且通用性不够好，另一种就是通过解决外部引用的方式实现，这种的兼容性较好，需要解决的问题就是在内部解析引用的时候实现内部导入。
案例分析
如果我们需要实现一个log函数，那么就需要解决外部符号导入问题，如下面代码：
int main() {
Println("hello world");
return 0;
}
它的wast文件为：
(module
(type $FUNCSIG$i (func (result i32)))
(type $FUNCSIG$ii (func (param i32) (result i32)))
(import "env" "Println" (func $Println (param i32) (result i32)))
(table 0 anyfunc)
(memory $0 1)
(data (i32.const 16) "hello world\00")
(export "memory" (memory $0))
(export "main" (func $main))
(func $main (; 1 ;) (result i32)
(drop
(call $Println
(i32.const 16)
)
)
(i32.const 0)
)
)
它的wasm文件内容如下：
pct@Chandler:~/go/src/github.com/go-interpreter/wagon/cmd/wasm-run$ wasm-dump -s hello.wasm
hello.wasm: module version: 0x1
contents of section type:
0000000e 02 60 00 01 7f 60 01 7f 01 7f |.`...`....|
contents of section import:
0000001e 01 03 65 6e 76 07 50 72 69 6e 74 6c 6e 00 01 |..env.Println..|
contents of section function:
00000033 01 00 |..|
contents of section table:
0000003b 01 70 00 00 |.p..|
contents of section memory:
00000045 01 00 01 |...|
contents of section global:
0000004e 00 |.|
contents of section export:
00000055 02 06 6d 65 6d 6f 72 79 02 00 04 6d 61 69 6e 00 |..memory...main.|
00000065 01 |.|
contents of section code:
0000006c 01 89 80 80 80 00 00 41 10 10 00 1a 41 00 0b |.......A....A..|
contents of section data:
00000081 01 00 41 10 0b 0c 68 65 6c 6c 6f 20 77 6f 72 6c |..A...hello worl|
00000091 64 00 |d.|
解析器在解析文件时需要找到env中的Println函数，然后将hello world放入堆栈，接着调用call函数执行Println函数打印出hello world，那么我们需要解决的就是在虚拟机内部实现env中Println函数的解析部分。
解析流程
在上一章节中我们分析过，文件的解析主要在函数wasm.ReadModule(f, importer)中，它首先循环读取各个分区：
for {
done, err := m.readSection(reader)
if err != nil {
return nil, err
} else if done {
break
}
}
然后再去解决导入的函数：
if m.Import != nil && resolvePath != nil {
err := m.resolveImports(resolvePath)
if err != nil {
return nil, err
}
}
这里的解决办法是从env的wasm文件中读取导入的函数：
for _, importEntry := range module.Import.Entries {
importedModule, ok := modules[importEntry.ModuleName]
if !ok {
var err error
importedModule, err = resolve(importEntry.ModuleName)
if err != nil {
return err
}
modules[importEntry.ModuleName] = importedModule
}
index := exportEntry.Index
switch exportEntry.Kind {
case ExternalFunction:
fn := importedModule.GetFunction(int(index))
if fn == nil {
return InvalidFunctionIndexError(index)
}
module.FunctionIndexSpace = append(module.FunctionIndexSpace, *fn)
module.Code.Bodies = append(module.Code.Bodies, *fn.Body)
module.imports.Funcs = append(module.imports.Funcs, funcs)
funcs++
然后再创建新的vm时会将函数列表放入vm中：
vm, err := exec.NewVM(m)
vm.newFuncTable()
vm.funcTable[ops.Call] = vm.call
最后根据堆栈来调用相关函数：
index := vm.fetchUint32()
vm.funcs[index].call(vm, int64(index))
函数从module到vm的拷贝过程如下：
for i, fn := range module.FunctionIndexSpace {
if fn.IsHost() {
vm.funcs[i] = goFunction{
typ: fn.Host.Type(),
val: fn.Host,
}
nNatives++
continue
}
disassembly, err := disasm.Disassemble(fn, module)
if err != nil {
return nil, err
}
totalLocalVars := 0
totalLocalVars += len(fn.Sig.ParamTypes)
for _, entry := range fn.Body.Locals {
totalLocalVars += int(entry.Count)
}
code, table := compile.Compile(disassembly.Code)
vm.funcs[i] = compiledFunction{
code: code,
branchTables: table,
maxDepth: disassembly.MaxDepth,
totalLocalVars: totalLocalVars,
args: len(fn.Sig.ParamTypes),
returns: len(fn.Sig.ReturnTypes) != 0,
}
}
那么这里的问题就是如何在保存现有解析新wasm文件的基础上，跳过对Println函数的解析呢？而且需要根据fn的规则实现一个内部的Println。
工程改造
首先是跳过部分，这部分比较简单，我们在解析外部引用时手动判断env并跳过即可：
for _, importEntry := range module.Import.Entries {
if importEntry.ModuleName == "env" {
fmt.Println("Module Name:", importEntry.ModuleName, "- Filed Name:", importEntry.FieldName)
if importEntry.Kind == ExternalFunction {
//get the function type
funcType := module.Types.Entries[importEntry.Type.(FuncImport).Type]
var code []byte
code = append(code, 0x41)
code = append(code, 0x0b)
fn := &Function{IsEnv: true, Name: importEntry.FieldName, Sig: &FunctionSig{ParamTypes: funcType.ParamTypes, ReturnTypes: funcType.ReturnTypes}, Body: &FunctionBody{Code:code}}
module.FunctionIndexSpace = append(module.FunctionIndexSpace, *fn)
module.Code.Bodies = append(module.Code.Bodies, *fn.Body)
module.imports.Funcs = append(module.imports.Funcs, funcs)
funcs++
}
}
这里就跳过了对env中Println的解析，注意这里需要添加code，否则会导致空指令的执行，这里的41表示call指令，我们需要在函数执行call时对自己的函数进行处理。 还有就是我们添加了两个变量，IsEnv和Name，这两个变量可以判断函数是否是我们自己实现的，从而实现外部函数的分支调用。
下一步就是创建新的VM了，创建新的VM时需要在函数列表中添加上我们加入的两个变量：
vm.funcs[i] = compiledFunction{
code: code,
branchTables: table,
maxDepth: disassembly.MaxDepth,
totalLocalVars: totalLocalVars,
args: len(fn.Sig.ParamTypes),
returns: len(fn.Sig.ReturnTypes) != 0,
IsEnv: fn.IsEnv,
Name: fn.Name,
}
}
然后函数执行时就会调用到我们放入的code：
func (vm *VM) ExecCode(fnIndex int64, args ...uint64) (rtrn interface{}, err error) {
compiled, ok := vm.funcs[fnIndex].(compiledFunction)
if !ok {
panic(fmt.Sprintf("exec: function at index %d is not a compiled function", fnIndex))
}
if len(vm.ctx.stack) < compiled.maxDepth {
vm.ctx.stack = make([]uint64, 0, compiled.maxDepth)
}
vm.ctx.locals = make([]uint64, compiled.totalLocalVars)
vm.ctx.pc = 0
vm.ctx.code = compiled.code
vm.ctx.curFunc = fnIndex
for i, arg := range args {
vm.ctx.locals[i] = arg
}
res := vm.execCode(compiled)
code里是0x41和0x2b，执行VM的函数调用：
func (vm *VM) execCode(compiled compiledFunction) uint64 {
outer:
for int(vm.ctx.pc) < len(vm.ctx.code) {
op := vm.ctx.code[vm.ctx.pc]
vm.ctx.pc++
switch op {
default:
fmt.Printf("Execte Code:0x%02x\n", op)
vm.funcTable[op]()
}
}
funcTable是在创建VM时设置的，实际调用的是vm的call函数：
func (vm *VM) call() {
index := vm.fetchUint32()
fun, ok := vm.funcs[index].(compiledFunction)
if ok {
if fun.IsEnv {
if fun.Name == "Println" {
fmt.Println("Println Call log aba")
vm.popUint64()
vm.pushUint64(0)
return
}
}
}
vm.funcs[index].call(vm, int64(index))
}
我们可以在这个函数中做分支，实现自己的API方法，当然，现在的Println函数并没有对堆栈进行处理，只是最简单的流程，如果涉及到堆栈处理，就更复杂一些了。