wasm技术介绍

//go:build tinygo

package main

import (
	"fmt"
	"reflect"
	"unsafe"
)

//export Add
//go:wasmexport
func Add(a, b int) int {
	return a + b
}

type User struct {
	Name string
	Age int
}

//export AddUser
func AddUser(nameData *byte, nameLen int, age int) bool {
	fmt.Println(nameLen, age)
	name := RawBytePtrToString(nameData, nameLen)

	user := User{Name: name, Age: age}
	fmt.Printf("Add User:%v\n", user)
	return true
}

func main() {
	fmt.Println("Hello, WebAssembly!")
}

func RawBytePtrToString(raw *byte, size int) string {
	//nolint
	return *(*string)(unsafe.Pointer(&reflect.SliceHeader{
		Data: uintptr(unsafe.Pointer(raw)),
		Len:  size,
		Cap:  size,
	}))
}

func RawBytePtrToByteSlice(raw *byte, size int) []byte {
	//nolint
	return *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{
		Data: uintptr(unsafe.Pointer(raw)),
		Len:  size,
		Cap:  size,
	}))
}

tinygo build -target wasip1 -o main.wasm main.go

git clone --recursive https://github.com/WebAssembly/wabt

cd wabt

git submodule update --init

mkdir build

cd build

cmake ..

cmake --build .

wasm2wat main.wasm

package main

import (
	"fmt"
	"log"

	"github.com/bytecodealliance/wasmtime-go/v29"
)

func main() {
	engine := wasmtime.NewEngine()
	store := wasmtime.NewStore(engine)
	// 配置 WASI 上下文
	wasiConfig := wasmtime.NewWasiConfig()
	wasiConfig.InheritStdout() // 继承标准输出
	store.SetWasi(wasiConfig)
	module, err := wasmtime.NewModuleFromFile(engine, "main.wasm")
	check(err)

	// 创建 Linker 并配置默认的 WASI 导入
	linker := wasmtime.NewLinker(engine)
	err = linker.DefineWasi()
	check(err)

	// 实例化模块
	instance, err := linker.Instantiate(store, module)
	check(err)

	addF := instance.GetExport(store, "Add").Func()
	val, err := addF.Call(store, 6, 27)
	check(err)
	fmt.Printf("add(6, 27) = %d\n", val.(int32))

	memory := instance.GetExport(store, "memory").Memory()
	fmt.Println(memory.DataSize(store), memory.Data(store))
	// 获取导出的 malloc 函数
	malloc := instance.GetExport(store, "malloc").Func()
	if malloc == nil {
		log.Fatalf("malloc function not found")
	}

	addUser := instance.GetExport(store, "AddUser").Func()
	if addUser == nil {
		log.Fatalf("AddUser function not found")
	}
	name := "Alice"
	nameData := []byte(name)
	nameLen := int32(len(name))
	// 调用 malloc 分配内存
	mallocResult, err := malloc.Call(store, nameLen+1)
	if err != nil {
		log.Fatalf("Failed to call malloc: %s", err)
	}
	namePtr := mallocResult.(int32)

	fmt.Println("namePtr", namePtr)
	fmt.Println(memory.DataSize(store), memory.Data(store))
	mem := memory.UnsafeData(store)
	fmt.Println("mem", len(mem))
	copy(mem[namePtr:], nameData)
	age := int32(30)

	// 调用 AddUser 函数
	result, err := addUser.Call(store, namePtr, nameLen, age)
	if err != nil {
		log.Fatalf("Failed to call AddUser: %s", err)
	}
	fmt.Println(result)

	// 获取导出的 free 函数并释放内存
	free := instance.GetExport(store, "free").Func()
	if free != nil {
		_, err = free.Call(store, namePtr)
		if err != nil {
			log.Fatalf("Failed to call free: %s", err)
		}
	}
}

func check(err error) {
	if err != nil {
		panic(err)
	}
}

package main

import (
	"fmt"
	"io/ioutil"

	wasmer "github.com/wasmerio/wasmer-go/wasmer"
)

func main() {

	wasmBytes, _ := ioutil.ReadFile("c.wasm")

	engine := wasmer.NewEngine()
	store := wasmer.NewStore(engine)

	// Compiles the module
	module, _ := wasmer.NewModule(store, wasmBytes)

	wasiVersion := wasmer.GetWasiVersion(module)
	fmt.Println(wasiVersion)
	wasiEnv, err := wasmer.NewWasiStateBuilder("wasi_snapshot_preview1").
		// Choose according to your actual situation
		// Argument("--foo").
		// Environment("ABC", "DEF").
		// MapDirectory("./", ".").
		Finalize()
	fmt.Println(wasiEnv, err)
	importObject, err := wasiEnv.GenerateImportObject(store, module)
	check(err)

	// importObject := wasmer.NewImportObject()
	instance, err := wasmer.NewInstance(module, importObject)
	check(err)

	// Gets the `sum` exported function from the WebAssembly instance.
	sum, err := instance.Exports.GetFunction("Add")

	check(err)

	// Calls that exported function with Go standard values. The WebAssembly
	// types are inferred and values are casted automatically.
	result, _ := sum(5, 37)

	if result != int32(42) {
		panic("result error")
	}

	fmt.Printf("%v %T\n", result, result)

	memory, err := instance.Exports.GetMemory("memory")
	check(err)

	malloc, err := instance.Exports.GetFunction("malloc")
	check(err)

	nameData := []byte("bruceding")
	age := 28

	namePtr, err := malloc(len(nameData) + 1)
	check(err)

	fmt.Println(memory.DataSize(), memory.Size())
	basePtr := namePtr.(int32)
	fmt.Println("basePtr", basePtr)
	buf := memory.Data()
	copy(buf[basePtr:], nameData)

	addUser, err := instance.Exports.GetFunction("AddUser")
	check(err)

	result, err = addUser(basePtr, len(nameData), age)
	check(err)
	fmt.Printf("%v %T\n", result, result)
	if result != int32(1) {
		panic("result error")
	}
}

func check(err error) {
	if err != nil {
		panic(err)
	}
}

git clone https://github.com/emscripten-core/emsdk

cd emsdk

./emsdk install latest

./emsdk activate latest

#include <stdio.h>

int Add(int i, int j) {
    return i + j;
}

int AddUser(char* nameData, int nameLen, int age) {

    if (!nameData) {
        return 0;
    }
  printf("name:%s, len:%d, age:%d\n", nameData, nameLen, age);
    return 1;
}
int main() {
  printf("hello, world!\n");
  return 0;
}

emcc -Os -s STANDALONE_WASM -s 'EXPORTED_FUNCTIONS=Add,AddUser,_malloc' -Wl,--no-entry hello_world.c -o c.wasm

git clone https://github.com/bytecodealliance/wasmtime.git

cd wasmtime

cargo build --release -p wasmtime-c-api

# 如果 rustc 版本较低，可以升级

rustup update stable

sudo cp target/release/libwasmtime.* /usr/local/lib64

sudo cp -r crates/c-api /usr/local/include

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <wasi.h>
#include <wasm.h>
#include <wasmtime.h>

#define MIN(a, b) ((a) < (b) ? (a) : (b))

static void exit_with_error(const char *message, wasmtime_error_t *error,
                            wasm_trap_t *trap);
int main() {
    // Set up our context
  wasm_engine_t *engine = wasm_engine_new();
  assert(engine != NULL);
  wasmtime_store_t *store = wasmtime_store_new(engine, NULL, NULL);
  assert(store != NULL);
  wasmtime_context_t *context = wasmtime_store_context(store);

 // Create a linker with WASI functions defined
  wasmtime_linker_t *linker = wasmtime_linker_new(engine);
  wasmtime_error_t *error = wasmtime_linker_define_wasi(linker);
  if (error != NULL)
    exit_with_error("failed to link wasi", error, NULL);

  wasm_byte_vec_t wasm;
  // Load our input file to parse it next
  FILE *file = fopen("./main.wasm", "rb");
  if (!file) {
    printf("> Error loading file!\n");
    exit(1);
  }
  fseek(file, 0L, SEEK_END);
  size_t file_size = ftell(file);
  wasm_byte_vec_new_uninitialized(&wasm, file_size);
  fseek(file, 0L, SEEK_SET);
  if (fread(wasm.data, file_size, 1, file) != 1) {
    printf("> Error loading module!\n");
    exit(1);
  }
  fclose(file);

  // Compile our modules
  wasmtime_module_t *module = NULL;
  error = wasmtime_module_new(engine, (uint8_t *)wasm.data, wasm.size, &module);
  if (!module)
    exit_with_error("failed to compile module", error, NULL);
  wasm_byte_vec_delete(&wasm);

  // Instantiate wasi
  wasi_config_t *wasi_config = wasi_config_new();
  assert(wasi_config);
  wasi_config_inherit_argv(wasi_config);
  wasi_config_inherit_env(wasi_config);
  wasi_config_inherit_stdin(wasi_config);
  wasi_config_inherit_stdout(wasi_config);
  wasi_config_inherit_stderr(wasi_config);
  wasm_trap_t *trap = NULL;
  error = wasmtime_context_set_wasi(context, wasi_config);
  if (error != NULL)
    exit_with_error("failed to instantiate WASI", error, NULL);


  wasmtime_instance_t instance;
  error = wasmtime_linker_instantiate(linker, context, module,  &instance, &trap);
  if (error != NULL || trap != NULL)
    exit_with_error("failed to instantiate", error, trap);

  wasmtime_extern_t addFunc;
  bool ok = wasmtime_instance_export_get(context, &instance, "Add", 3, &addFunc);
  assert(ok);
  assert(addFunc.kind == WASMTIME_EXTERN_FUNC);

  int a = 6;
  int b = 27;
  wasmtime_val_t params[2];
  params[0].kind = WASMTIME_I32;
  params[0].of.i32 = a;
  params[1].kind = WASMTIME_I32;
  params[1].of.i32 = b;
  wasmtime_val_t results[1];
  error =
      wasmtime_func_call(context, &addFunc.of.func, params, 2, results, 1, &trap);
  if (error != NULL || trap != NULL)
    exit_with_error("failed to call add", error, trap);
  assert(results[0].kind == WASMTIME_I32);

  printf("add(%d, %d) = %d\n", a, b, results[0].of.i32);

  // Clean up after ourselves at this point
  wasmtime_module_delete(module);
  wasmtime_store_delete(store);
  wasm_engine_delete(engine);

   return 0;
}

static void exit_with_error(const char *message, wasmtime_error_t *error,
                            wasm_trap_t *trap) {
  fprintf(stderr, "error: %s\n", message);
  wasm_byte_vec_t error_message;
  if (error != NULL) {
    wasmtime_error_message(error, &error_message);
    wasmtime_error_delete(error);
  } else {
    wasm_trap_message(trap, &error_message);
    wasm_trap_delete(trap);
  }
  fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
  wasm_byte_vec_delete(&error_message);
  exit(1);
}