Tidy up serialization layer

compiler/coroutine_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/dispatchrun/coroutine"
 	. "github.com/dispatchrun/coroutine/compiler/testdata"
+	"github.com/dispatchrun/coroutine/internal/reflectext"
 	"github.com/dispatchrun/coroutine/types"
 )
 
@@ -313,12 +314,12 @@ func TestCoroutineYield(t *testing.T) {
 	// package.
 	for _, test := range tests {
 		if test.coro != nil {
-			addr := types.FuncAddr(test.coro)
-			fn := types.FuncByAddr(addr)
+			addr := reflectext.FuncAddr(test.coro)
+			fn := reflectext.FuncByAddr(addr)
 			types.RegisterFunc[func()](fn.Name)
 		} else {
-			addr := types.FuncAddr(test.coroR)
-			fn := types.FuncByAddr(addr)
+			addr := reflectext.FuncAddr(test.coroR)
+			fn := reflectext.FuncByAddr(addr)
 			types.RegisterFunc[func() int](fn.Name)
 		}
 	}

compiler/testdata/coroutine_durable.go

@@ -3519,7 +3519,7 @@ func IdentityGenericInt(n int) { IdentityGeneric[int](n) }
 
 //go:noinline
 func IdentityGenericClosure[T any](_fn0 T) {
-	_c := coroutine.LoadContext[int, any]()
+	_c := coroutine.LoadContext[T, any]()
 	var _f0 *struct {
 		IP int
 		X0 T

internal/reflectext/buildid.go

@@ -0,0 +1,8 @@
+package reflectext
+
+var buildID string
+
+// BuildID is the build identifier for the binary.
+func BuildID() string {
+	return buildID
+}

internal/reflectext/func.go

@@ -0,0 +1,160 @@
+package reflectext
+
+import (
+	"debug/gosym"
+	"errors"
+	"io"
+	"reflect"
+	"runtime"
+	"unsafe"
+)
+
+// Func represents a function in the program.
+type Func struct {
+	// The address where the function exists in the program memory.
+	Addr uintptr
+
+	// The name that uniquely represents the function.
+	//
+	// For regular functions, this values has the form <package>.<function>.
+	//
+	// For closures, this value has the form <package>.<function>.func<N>, where
+	// N starts at 1 and increments for each closure defined in the function.
+	Name string
+
+	// A type representing the signature of the function value.
+	//
+	// This field is nil if the type is unknown; by default the field is nil and
+	// the program is expected to initialize it to a non-nil value for functions
+	// that may be serialized.
+	//
+	// If non-nil, the type must be of kind reflect.Func.
+	Type reflect.Type
+
+	// A struct type representing the memory layout of the closure.
+	//
+	// This field is nil if the type is unknown; by default the field is nil and
+	// the program is expected to initialize it to a non-nil value for closures
+	// that may be serialized. For regular functions, this field can remain nil
+	// since regular functions do not capture any values.
+	//
+	// If non-nil, the first field of the struct type must be a uintptr intended
+	// to hold the address to the function value.
+	Closure reflect.Type
+}
+
+// RegisterFunc is a helper function used to register function types. The type
+// parameter must be a function type, but no compile nor runtime checks are used
+// to enforce it; passing anything other than a function type will likely result
+// in panics later on when the program attempts to serialize the function value.
+//
+// The name argument is a unique identifier of the Go symbol that represents the
+// function, which has the package path as prefix, and the dot-separated sequence
+// identifying the function in the package.
+func RegisterFunc[Type any](name string) {
+	if f := FuncByName(name); f != nil {
+		f.Type = reflect.TypeFor[Type]()
+	}
+}
+
+// RegisterClosure is like RegisterFunc but the caller can specify the closure
+// type (see types.Func for details).
+func RegisterClosure[Type, Closure any](name string) {
+	if f := FuncByName(name); f != nil {
+		f.Type, f.Closure = reflect.TypeFor[Type](), reflect.TypeFor[Closure]()
+	}
+}
+
+// FuncAddr returns the address in memory of the closure passed as argument.
+//
+// This function can only resolve addresses of closures in the compilation unit
+// that it is part of; for example, if compiled in a Go plugin, it can only
+// resolve the address of functions within that plugin, and the main program
+// cannot resolve addresses of functions in the plugins it loaded.
+//
+// If the argument is a nil function value, the return address is zero.
+//
+// The function panics if called with a value which is not a function.
+func FuncAddr(fn any) uintptr {
+	if reflect.TypeOf(fn).Kind() != reflect.Func {
+		panic("value must be a function")
+	}
+	header := (*functionHeader)((*interfaceHeader)(unsafe.Pointer(&fn)).ptr)
+	if header == nil {
+		return 0
+	}
+	return uintptr(header.addr)
+}
+
+// FuncByName returns the function associated with the given name.
+//
+// Addresses in the returned Func value hold the value of the symbol location in
+// the program memory.
+//
+// If the name passed as argument does not represent any function, the function
+// returns nil.
+func FuncByName(name string) *Func { return functionsByName[name] }
+
+// FuncByAddr returns the function associated with the given address.
+//
+// Addresses in the returned Func value hold the value of the symbol location in
+// the program memory.
+//
+// If the address passed as argument is not the address of a function in the
+// program, the function returns nil.
+func FuncByAddr(addr uintptr) *Func { return functionsByAddr[addr] }
+
+var (
+	functionsByName map[string]*Func
+	functionsByAddr map[uintptr]*Func
+)
+
+func initFunctionTables(pclntab, symtab []byte) {
+	table, err := gosym.NewTable(symtab, gosym.NewLineTable(pclntab, 0))
+	if err != nil {
+		panic("cannot read symtab: " + err.Error())
+	}
+
+	sentinelName, sentinelAddr := sentinel()
+
+	tableFunc := table.LookupFunc(sentinelName)
+	offset := uint64(sentinelAddr) - tableFunc.Entry
+
+	functions := make([]Func, len(table.Funcs))
+	for i, fn := range table.Funcs {
+		functions[i] = Func{
+			Addr: uintptr(fn.Entry + offset),
+			Name: fn.Name,
+		}
+	}
+
+	functionsByName = make(map[string]*Func, len(functions))
+	functionsByAddr = make(map[uintptr]*Func, len(functions))
+
+	for i := range functions {
+		f := &functions[i]
+		functionsByName[f.Name] = f
+		functionsByAddr[f.Addr] = f
+	}
+}
+
+func readSection(r io.ReaderAt, size uint64) ([]byte, error) {
+	if r == nil {
+		return nil, errors.New("section missing")
+	}
+	b := make([]byte, size)
+	n, err := r.ReadAt(b, 0)
+	if err != nil && n < len(b) {
+		return nil, err
+	}
+	return b, nil
+}
+
+//go:noinline
+func sentinel() (name string, addr uintptr) {
+	pc := [1]uintptr{}
+	runtime.Callers(0, pc[:])
+
+	fn := runtime.FuncForPC(pc[0])
+	return fn.Name(), fn.Entry()
+}

types/func_test.go → internal/reflectext/func_test.go

@@ -1,4 +1,4 @@
-package types
+package reflectext
 
 import (
 	"reflect"
@@ -31,7 +31,7 @@ func TestFunctionAddress(t *testing.T) {
 }
 
 func TestFunctionLookup(t *testing.T) {
-	name := "github.com/dispatchrun/coroutine/types.TestFunctionLookup"
+	name := "github.com/dispatchrun/coroutine/internal/reflectext.TestFunctionLookup"
 	sym1 := FuncByName(name)
 	sym2 := FuncByAddr(FuncAddr(TestFunctionLookup))
 
@@ -42,11 +42,10 @@ func TestFunctionLookup(t *testing.T) {
 
 func TestClosureAddress(t *testing.T) {
 	f := op(42, 1)
-	p := *(*unsafe.Pointer)(unsafe.Pointer(&f))
-	c := (*closure)(p)
+	header := *(**functionHeader)(unsafe.Pointer(&f))
 
-	name := "github.com/dispatchrun/coroutine/types.op.func1"
-	addr1 := c.addr
+	name := "github.com/dispatchrun/coroutine/internal/reflectext.op.func1"
+	addr1 := uintptr(header.addr)
 	addr2 := FuncAddr(f)
 
 	if addr1 != addr2 {
@@ -57,7 +56,7 @@ func TestClosureAddress(t *testing.T) {
 func TestClosureLookup(t *testing.T) {
 	f := op(1, 2)
 
-	name := "github.com/dispatchrun/coroutine/types.op.func1"
+	name := "github.com/dispatchrun/coroutine/internal/reflectext.op.func1"
 	sym1 := FuncByName(name)
 	sym2 := FuncByAddr(FuncAddr(f))
 
@@ -67,7 +66,7 @@ func TestClosureLookup(t *testing.T) {
 }
 
 func TestRehydrateFunction(t *testing.T) {
-	f := FuncByName("github.com/dispatchrun/coroutine/types.op")
+	f := FuncByName("github.com/dispatchrun/coroutine/internal/reflectext.op")
 	v := reflect.New(f.Type)
 	p := v.UnsafePointer()
 
@@ -88,7 +87,7 @@ func TestRehydrateFunction(t *testing.T) {
 }
 
 func TestRehydrateClosure(t *testing.T) {
-	f := FuncByName("github.com/dispatchrun/coroutine/types.op.func1")
+	f := FuncByName("github.com/dispatchrun/coroutine/internal/reflectext.op.func1")
 	v := reflect.New(f.Closure)
 	p := v.UnsafePointer()
 
@@ -125,10 +124,10 @@ type opFunc1Closure struct {
 // This init function contains the work that would normally be done by the
 // compiler to generate the reflect data necessary to serialize functions.
 func init() {
-	op := FuncByName("github.com/dispatchrun/coroutine/types.op")
+	op := FuncByName("github.com/dispatchrun/coroutine/internal/reflectext.op")
 	op.Type = reflect.TypeOf(func(int, int) (_ func() int) { return })
 
-	fn := FuncByName("github.com/dispatchrun/coroutine/types.op.func1")
+	fn := FuncByName("github.com/dispatchrun/coroutine/internal/reflectext.op.func1")
 	fn.Type = reflect.TypeOf(func() (_ int) { return })
 	fn.Closure = reflect.TypeOf(opFunc1Closure{})
 }

types/obj_darwin.go → internal/reflectext/obj_darwin.go

@@ -1,4 +1,4 @@
-package types
+package reflectext
 
 import (
 	"bytes"

types/obj_linux.go → internal/reflectext/obj_linux.go

@@ -1,4 +1,4 @@
-package types
+package reflectext
 
 import (
 	"bytes"

internal/reflectext/type.go

@@ -0,0 +1,39 @@
+package reflectext
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+var (
+	AnyType = reflect.TypeFor[any]()
+
+	BoolType = reflect.TypeFor[bool]()
+
+	IntType   = reflect.TypeFor[int]()
+	Int8Type  = reflect.TypeFor[int8]()
+	Int16Type = reflect.TypeFor[int16]()
+	Int32Type = reflect.TypeFor[int32]()
+	Int64Type = reflect.TypeFor[int64]()
+
+	UintType   = reflect.TypeFor[uint]()
+	Uint8Type  = reflect.TypeFor[uint8]()
+	Uint16Type = reflect.TypeFor[uint16]()
+	Uint32Type = reflect.TypeFor[uint32]()
+	Uint64Type = reflect.TypeFor[uint64]()
+
+	Float32Type = reflect.TypeFor[float32]()
+	Float64Type = reflect.TypeFor[float64]()
+
+	Complex64Type  = reflect.TypeFor[complex64]()
+	Complex128Type = reflect.TypeFor[complex128]()
+
+	ByteType   = reflect.TypeFor[byte]()
+	StringType = reflect.TypeFor[string]()
+
+	UintptrType       = reflect.TypeFor[uintptr]()
+	UnsafePointerType = reflect.TypeFor[unsafe.Pointer]()
+
+	ReflectValueType = reflect.TypeFor[reflect.Value]()
+	ReflectTypeType  = reflect.TypeFor[reflect.Type]()
+)