Is go-wasmer can handle C codes?

[AchalaSB]

Using go-wasmer we were able to handle Rust code by calling extern function.

can we do same for C codes?
is it compatible now?

If yes. How can we call C code as an extern function?

[Hywan]

If your C code is compiled to WebAssembly, yes, it will work!

[AchalaSB]

Yea, we can compile C code to wasm.
So again wasmer requires the C code as extern function only?

Is there any examples, go-wasmer handles C code?

[Hywan]

So far, a useful tool is https://emscripten.org/. More to come in few days :-).

[AchalaSB]

Using emscripten we can compile. but that can't be use in go-wasmer.
We can compile using WASI if that supports in go-wasmer its good to go. (even for Rust)

I see go-wasmer is working on WASI. Waiting for WASI support

[Hywan]

Few days later

We've released wasienv, check it out https://medium.com/wasmer/wasienv-wasi-development-workflow-for-humans-1811d9a50345 :-)

[AchalaSB]

This looks good to me. But my feature request is to handle wasm bytecode(from C/C++ code) in go module.

This wasienv is usable in only in wasmer if I'm not wrong

[Hywan]

wasienv helps to compile a C/C++ program to Wasm (with WASI support), and then you can use this Wasm module anywhere, incl. this project.

[AchalaSB]

Thanks will try with go module.
Is there any specific way to write code in C/C++ like in Rust for this project?
If so can I get any simple example.

[Hywan]

Nothing I'm aware of. What do you want to know?

[AchalaSB]

i'm trying to run C code in go-wasmer. C code compiled in wasm using WASI
main.c

#include<stdio.h>
int main(int argc, char **argv)
{
  if (argc < 4) {
    printf("Hello, WASI!\n");
  } else {
    printf("Hello, %s!\n", argv[1]);
  }
}

main.go

package main

/*
#include<stdio.h>
#include<stdlib.h>
int main(int argc, char **argv)
{
  if (argc < 4) {
    printf("Hello, WASI!\n");
  } else {
    printf("Hello, %s!\n", argv[1]);
  }
}
*/
import "C"
import (
	"fmt"
	wasm "github.com/wasmerio/go-ext-wasm/wasmer"
)
func test(x int32) int32{
	return x
}

func main() {
	// Reads the WebAssembly module as bytes.
         bytes, _ := wasm.ReadBytes("/home/achala/codes/wasm-play/src/new.wasm")
	imports, _ := wasm.NewImports().Append("test", test, C.test)
	instance, err := wasm.NewInstanceWithImports(bytes, imports)
	if err != nil {
		panic(err)
	  }
	defer instance.Close()
	res := instance.Exports["main"]
	result, _ := res(2)
	fmt.Println(result) 
}

This is endup error

# command-line-arguments
./Ctest.go:29:55: could not determine kind of name for C.test

If I remove test function and imports just doing in normal export way. got this error

# command-line-arguments
/tmp/go-build871956597/b001/_x002.o: In function `main':
./Ctest.go:8: multiple definition of `main'
/tmp/go-build871956597/b001/_cgo_main.o:/tmp/go-build/_cgo_main.c:1: first defined here
collect2: error: ld returned 1 exit status

How can I call C/C++ code in go-wasmer ?

[Hywan]

Considering #92 is merged (it still a draft, it's blocked by wasmerio/wasmer#1028 and wasmerio/wasmer#1030, they are all landing very soon).

Let's consider the following C++ program:

#include <stdio.h>

extern "C" {
  int32_t sum(int32_t, int32_t) __attribute__((used));
  int32_t sum(int32_t x, int32_t y) {
    return x + y;
  }
}

int main(int argc, char **argv) {
  if (argc < 2) {
    printf("Hello, WASI!\n");
  } else {
    printf("Hello, %s!\n", argv[1]);
  }
}

You can compile it with:

$ wasicc wasi_c.cpp -o wasi_c

Then from Go:

module, err := wasm.Compile(getBytes("wasi_c.wasm"))
assert.NoError(t, err)

wasiVersion := wasm.WasiGetVersion(module)
assert.Equal(t, wasiVersion, wasm.Snapshot0)

importObject := wasm.NewDefaultWasiImportObjectForVersion(wasiVersion)

instance, err := module.InstantiateWithImportObject(importObject)
assert.NoError(t, err)

defer instance.Close()

// `_starts` calls the `main` function. It prints `Hello, WASI!`.
start, exists := instance.Exports["_start"]
assert.Equal(t, true, exists)

_, err = start()
assert.NoError(t, err)

// `sum` is a regular exported function.
sum, exists := instance.Exports["sum"]
assert.Equal(t, true, exists)

output, err := sum(1, 2)
assert.NoError(t, err)
assert.Equal(t, wasm.I32(3), output)

As soon as the PR mentionned above are merged, we have to wait for a new Wasmer release, and we will good to go!

Hope it helps.