Merge pull request #249 from bytecodealliance/ydnar/wasm

internal/wasm: prototype package for wasm file manipulation

Author: ydnar

internal/wasm/section.go

@@ -0,0 +1,52 @@
+package wasm
+
+// SectionID represents a WebAssembly [section SectionID].
+//
+// [section SectionID]: https://webassembly.github.io/spec/core/binary/modules.html#sections
+type SectionID uint8
+
+const (
+	SectionCustom    SectionID = 0
+	SectionType      SectionID = 1
+	SectionImport    SectionID = 2
+	SectionFunction  SectionID = 3
+	SectionTable     SectionID = 4
+	SectionMemory    SectionID = 5
+	SectionGlobal    SectionID = 6
+	SectionExport    SectionID = 7
+	SectionStart     SectionID = 8
+	SectionElement   SectionID = 9
+	SectionCode      SectionID = 10
+	SectionData      SectionID = 11
+	SectionDataCount SectionID = 12
+)
+
+// Section represents an abstract [WebAssembly section].
+//
+// [WebAssembly section]: https://webassembly.github.io/spec/core/binary/modules.html#sections
+type Section interface {
+	// SectionID returns the section ID of this section.
+	SectionID() SectionID
+
+	// SectionContents returns the section contents as a byte slice.
+	SectionContents() ([]byte, error)
+}
+
+// CustomSection represents a [WebAssembly custom section].
+//
+// [WebAssembly custom section]: https://webassembly.github.io/spec/core/binary/modules.html#binary-customsec
+type CustomSection struct {
+	Name     string
+	Contents []byte
+}
+
+// SectionID implements the [Section] interface.
+func (*CustomSection) SectionID() SectionID {
+	return SectionCustom
+}
+
+// SectionContents implements the [Section] interface.
+func (s *CustomSection) SectionContents() ([]byte, error) {
+	// TODO: encode name correctly
+	return append([]byte(s.Name), s.Contents...), nil
+}

internal/wasm/sleb128/sleb128.go

@@ -0,0 +1,59 @@
+// Package sleb128 reads and writes signed LEB128 integers.
+package sleb128
+
+import (
+	"io"
+	"unsafe"
+)
+
+// Read reads a signed [LEB128] value from r.
+// Returns the value, number of bytes read, and/or an error.
+//
+// [LEB128]: https://en.wikipedia.org/wiki/LEB128
+func Read(r io.ByteReader) (v int64, n int, err error) {
+	shift := 0
+	for {
+		b, err := r.ReadByte()
+		if err != nil {
+			return 0, n, err
+		}
+		n++
+		v |= int64(b&0x7f) << shift
+		shift += 7
+		if (b & 0x80) == 0 {
+			if shift < int(unsafe.Sizeof(v)<<8) && (b&0x40) != 0 {
+				v |= (^0 << shift)
+			}
+			break
+		}
+	}
+	return v, n, nil
+}
+
+// Write writes v in signed [LEB128] format to w.
+// Returns the number of bytes written and/or an error.
+//
+// Adapted from the Go standard library with the following copyright:
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+//
+// [LEB128]: https://en.wikipedia.org/wiki/LEB128
+func Write(w io.ByteWriter, v int64) (n int, err error) {
+	more := true
+	for more {
+		c := uint8(v & 0x7f)
+		s := uint8(v & 0x40)
+		v >>= 7
+		more = (v != 0 || s != 0) && (v != -1 || s == 0)
+		if more {
+			c |= 0x80
+		}
+		err = w.WriteByte(c)
+		if err != nil {
+			return n, err
+		}
+		n++
+	}
+	return n, nil
+}

internal/wasm/sleb128/sleb128_test.go

@@ -0,0 +1,38 @@
+package sleb128
+
+import (
+	"bytes"
+	"math"
+	"testing"
+)
+
+func TestReadWrite(t *testing.T) {
+	tests := []int64{
+		0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+		-1, -2, -3, -4, -5, -6, -7, -8, -9, -10,
+		1 << 7, 1 << 8, 1 << 9,
+		-1 << 7, -1 << 8, -1 << 9,
+		math.MinInt64, math.MaxInt64,
+	}
+	for _, want := range tests {
+		got, b, err := roundTrip(want)
+		if err != nil {
+			t.Errorf("roundTrip(%d): error: %v", want, err)
+			continue
+		}
+		if got != want {
+			t.Errorf("roundTrip(%d): got %d (%x)", want, got, b)
+		}
+	}
+}
+
+func roundTrip(v int64) (int64, []byte, error) {
+	var buf bytes.Buffer
+	_, err := Write(&buf, v)
+	b := buf.Bytes()
+	if err != nil {
+		return 0, b, err
+	}
+	v, _, err = Read(bytes.NewReader(b))
+	return v, b, err
+}

internal/wasm/uleb128/uleb128.go

@@ -0,0 +1,52 @@
+// Package uleb128 reads and writes unsigned LEB128 integers.
+package uleb128
+
+import "io"
+
+// Read reads an unsigned [LEB128] value from r.
+// Returns the value, number of bytes read, and/or an error.
+//
+// [LEB128]: https://en.wikipedia.org/wiki/LEB128
+func Read(r io.ByteReader) (v uint64, n int, err error) {
+	shift := 0
+	for {
+		b, err := r.ReadByte()
+		if err != nil {
+			return 0, n, err
+		}
+		n++
+		v |= uint64(b&0x7f) << shift
+		if (b & 0x80) == 0 {
+			break
+		}
+		shift += 7
+	}
+	return v, n, nil
+}
+
+// Write writes v in unsigned [LEB128] format to w.
+// Returns the number of bytes written and/or an error.
+//
+// Adapted from the Go standard library with the following copyright:
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+//
+// [LEB128]: https://en.wikipedia.org/wiki/LEB128
+func Write(w io.ByteWriter, v uint64) (n int, err error) {
+	more := true
+	for more {
+		c := uint8(v & 0x7f)
+		v >>= 7
+		more = v != 0
+		if more {
+			c |= 0x80
+		}
+		err = w.WriteByte(c)
+		if err != nil {
+			return n, err
+		}
+		n++
+	}
+	return n, nil
+}

internal/wasm/uleb128/uleb128_test.go

@@ -0,0 +1,36 @@
+package uleb128
+
+import (
+	"bytes"
+	"math"
+	"testing"
+)
+
+func TestReadWrite(t *testing.T) {
+	tests := []uint64{
+		0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+		1 << 7, 1 << 8, 1 << 9,
+		math.MaxUint64,
+	}
+	for _, want := range tests {
+		got, b, err := roundTrip(want)
+		if err != nil {
+			t.Errorf("roundTrip(%d): error: %v", want, err)
+			continue
+		}
+		if got != want {
+			t.Errorf("roundTrip(%d): got %d (%x)", want, got, b)
+		}
+	}
+}
+
+func roundTrip(v uint64) (uint64, []byte, error) {
+	var buf bytes.Buffer
+	_, err := Write(&buf, v)
+	b := buf.Bytes()
+	if err != nil {
+		return 0, b, err
+	}
+	v, _, err = Read(bytes.NewReader(b))
+	return v, b, err
+}

internal/wasm/wasm.go

@@ -0,0 +1,85 @@
+package wasm
+
+import (
+	"bufio"
+	"io"
+
+	"go.bytecodealliance.org/internal/wasm/uleb128"
+)
+
+const (
+	Magic    = "\x00asm"
+	Version1 = "\x01\x00\x00\x00"
+)
+
+// Write writes a binary [WebAssembly module] to w.
+//
+// [WebAssembly module]: https://webassembly.github.io/spec/core/binary/modules.html#binary-module
+func Write(w io.Writer, sections []Section) error {
+	err := WriteModuleHeader(w)
+	if err != nil {
+		return err
+	}
+	for _, s := range sections {
+		contents, err := s.SectionContents()
+		if err != nil {
+			return err
+		}
+		_, err = WriteSectionHeader(w, s.SectionID(), uint64(len(contents)))
+		if err != nil {
+			return err
+		}
+		_, err = w.Write(contents)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// WriteModuleHeader writes a binary [WebAssembly module header] (version 1) to w.
+//
+// [WebAssembly module header]: https://webassembly.github.io/spec/core/binary/modules.html#binary-module
+func WriteModuleHeader(w io.Writer) error {
+	_, err := w.Write([]byte(Magic))
+	if err != nil {
+		return err
+	}
+	_, err = w.Write([]byte(Version1))
+	return err
+}
+
+// WriteSectionHeader writes a binary [WebAssembly section header] to w.
+// It returns the number of bytes written and/or an error.
+//
+// [WebAssembly section header]: https://webassembly.github.io/spec/core/binary/modules.html#sections
+func WriteSectionHeader(w io.Writer, id SectionID, size uint64) (n int, err error) {
+	bw := bufio.NewWriter(w)
+	err = bw.WriteByte(byte(id))
+	if err != nil {
+		return 0, err
+	}
+	n, err = uleb128.Write(bw, size)
+	if err != nil {
+		return n + 1, err
+	}
+	return n + 1, bw.Flush()
+}
+
+// WriteString writes a string to w as a [LEB128] encoded length followed by the string bytes.
+// Returns the number of bytes written and/or an error.
+//
+// [LEB128]: https://en.wikipedia.org/wiki/LEB128
+func WriteString(w io.Writer, s string) (n int, err error) {
+	bw := bufio.NewWriter(w)
+	n, err = uleb128.Write(bw, uint64(len(s)))
+	if err != nil {
+		return n, err
+	}
+	ns, err := bw.WriteString(s)
+	n += ns
+	if err != nil {
+		return n, err
+	}
+	return n, bw.Flush()
+}

wit/bindgen/generator.go

@@ -2217,6 +2217,16 @@ func (g *generator) wasmFileFor(owner wit.TypeOwner) *gen.File {
 	return file
 }
 
+func (g *generator) cgoFileFor(owner wit.TypeOwner) *gen.File {
+	pkg := g.packageFor(owner)
+	file := pkg.File(pkg.Name + ".cgo.go")
+	file.GeneratedBy = g.opts.generatedBy
+	if file.GoBuild == "" {
+		file.GoBuild = "tinygo.wasm"
+	}
+	return file
+}
+
 func (g *generator) packageFor(owner wit.TypeOwner) *gen.Package {
 	return g.witPackages[owner]
 }
@@ -2287,5 +2297,23 @@ func (g *generator) newPackage(w *wit.World, i *wit.Interface, name string) (*ge
 	g.exportScopes[owner] = gen.NewScope(nil)
 	pkg.DeclareName("Exports")
 
+	// Write a Cgo file that adds a library to the linker arguments.
+	// The library is a WebAssembly file that includes a custom section
+	// with a name prefixed with "component-type:". The contents are the
+	// Component Model definition for a world that encapsulates the
+	// Component Model types and functions imported into and/or exported
+	// from this Go package.
+	if false {
+		cgoFile := g.cgoFileFor(owner)
+		lib := id.String()
+		if name != id.Extension {
+			lib += "-" + name
+		}
+		lib = strings.ReplaceAll(lib, "/", "-")
+		lib = strings.ReplaceAll(lib, ":", "-")
+		stringio.Write(cgoFile, "// #cgo LDFLAGS: -L. -l", lib, "\n")
+		stringio.Write(cgoFile, "import \"C\"\n")
+	}
+
 	return pkg, nil
 }