ssa: abi type support anonymouse struct methods

Author: visualfc

_demo/go/abimethod/main.go

@@ -0,0 +1,205 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"sync/atomic"
+	"unsafe"
+)
+
+func main() {
+	testGeneric()
+	testNamed1()
+	testNamed2()
+	testNamed3()
+	testAnonymous1()
+	testAnonymous2()
+	testAnonymous3()
+	testAnonymous4()
+	testAnonymous5()
+	testAnonymous6()
+	testAnonymous7()
+	testAnonymous8()
+	testAnonymousBuffer()
+}
+
+func testNamed1() {
+	var a I = &T{100}
+	if a.Demo1() != 100 {
+		panic("testNamed1 error")
+	}
+}
+
+func testNamed2() {
+	var a I = T{100}
+	if a.Demo1() != 100 {
+		panic("testNamed2 error")
+	}
+}
+
+func testNamed3() {
+	var a I2 = &T{100}
+	if a.Demo2() != 100 {
+		panic("testNamed4 error")
+	}
+}
+
+type Pointer[T any] struct {
+	// Mention *T in a field to disallow conversion between Pointer types.
+	// See go.dev/issue/56603 for more details.
+	// Use *T, not T, to avoid spurious recursive type definition errors.
+	_ [0]*T
+	v unsafe.Pointer
+}
+
+// Load atomically loads and returns the value stored in x.
+func (x *Pointer[T]) Load() *T { return (*T)(atomic.LoadPointer(&x.v)) }
+
+// Store atomically stores val into x.
+func (x *Pointer[T]) Store(val *T) { atomic.StorePointer(&x.v, unsafe.Pointer(val)) }
+
+type IP interface {
+	Store(*any)
+	Load() *any
+}
+
+func testGeneric() {
+	var p IP = &Pointer[any]{}
+	p.Store(func() *any {
+		var a any = 100
+		return &a
+	}())
+	if (*p.Load()).(int) != 100 {
+		panic("testGeneric error")
+	}
+}
+
+func testAnonymous1() {
+	var s I = &struct {
+		m int
+		*T
+	}{10, &T{100}}
+	if s.Demo1() != 100 {
+		panic("testAnonymous1 error")
+	}
+}
+
+func testAnonymous2() {
+	var s I = struct {
+		m int
+		*T
+	}{10, &T{100}}
+	if s.Demo1() != 100 {
+		panic("testAnonymous2 error")
+	}
+}
+
+func testAnonymous3() {
+	var s I = struct {
+		m int
+		T
+	}{10, T{100}}
+	if s.Demo1() != 100 {
+		panic("testAnonymous3 error")
+	}
+}
+
+func testAnonymous4() {
+	var s I = &struct {
+		m int
+		T
+	}{10, T{100}}
+	if s.Demo1() != 100 {
+		panic("testAnonymous4 error")
+	}
+}
+
+func testAnonymous5() {
+	var s I2 = &struct {
+		m int
+		T
+	}{10, T{100}}
+	if s.Demo2() != 100 {
+		panic("testAnonymous5 error")
+	}
+}
+
+func testAnonymous6() {
+	var s I2 = struct {
+		m int
+		*T
+	}{10, &T{100}}
+	if s.Demo2() != 100 {
+		panic("testAnonymous6 error")
+	}
+}
+
+func testAnonymous7() {
+	var s interface {
+		Demo1() int
+		Demo2() int
+	} = struct {
+		m int
+		*T
+	}{10, &T{100}}
+	if s.Demo1() != 100 {
+		panic("testAnonymous7 error")
+	}
+	if s.Demo2() != 100 {
+		panic("testAnonymous7 error")
+	}
+}
+
+func testAnonymous8() {
+	var s interface {
+		Demo1() int
+		Demo2() int
+		demo3() int
+	} = struct {
+		m int
+		*T
+	}{10, &T{100}}
+	if s.Demo1() != 100 {
+		panic("testAnonymous8 error")
+	}
+	if s.Demo2() != 100 {
+		panic("testAnonymous8 error")
+	}
+	if s.demo3() != 100 {
+		panic("testAnonymous8 error")
+	}
+}
+
+func testAnonymousBuffer() {
+	var s fmt.Stringer = &struct {
+		m int
+		*bytes.Buffer
+	}{10, bytes.NewBufferString("hello")}
+	if s.String() != "hello" {
+		panic("testAnonymousBuffer error")
+	}
+}
+
+type T struct {
+	n int
+}
+
+func (t T) Demo1() int {
+	return t.n
+}
+
+func (t *T) Demo2() int {
+	return t.n
+}
+
+func (t *T) demo3() int {
+	return t.n
+}
+
+type I interface {
+	Demo1() int
+}
+
+type I2 interface {
+	Demo2() int
+}

_demo/go/reflectmakefn/main.go _demo/go/reflectmake/main.go_demo/go/reflectmakefn/main.go renamed to _demo/go/reflectmake/main.go

@@ -13,6 +13,14 @@ func main() {
 	})
 	r := fn.Interface().(func(string, int) string)("abc", 2)
 	if r != "abcabc" {
-		panic("reflect.MakeFunc error")
+		panic("reflect.FuncOf error")
 	}
+	_, ok := reflect.New(reflect.SliceOf(reflect.TypeOf(t{}))).Elem().Interface().([]t)
+	if !ok {
+		panic("reflect.SliceOf error")
+	}
+}
+
+type t struct {
+	n int
 }

cl/_testgo/tpinst/out.ll

@@ -190,14 +190,6 @@ _llgo_0:
 
 declare ptr @"github.com/goplus/llgo/runtime/internal/runtime.AllocZ"(i64)
 
-declare i1 @"github.com/goplus/llgo/runtime/internal/runtime.memequalptr"(ptr, ptr)
-
-define linkonce i1 @"__llgo_stub.github.com/goplus/llgo/runtime/internal/runtime.memequalptr"(ptr %0, ptr %1, ptr %2) {
-_llgo_0:
-  %3 = tail call i1 @"github.com/goplus/llgo/runtime/internal/runtime.memequalptr"(ptr %1, ptr %2)
-  ret i1 %3
-}
-
 define linkonce i64 @"github.com/goplus/llgo/cl/_testgo/tpinst.(*M[int]).Value"(ptr %0) {
 _llgo_0:
   %1 = getelementptr inbounds %"github.com/goplus/llgo/cl/_testgo/tpinst.M[int]", ptr %0, i32 0, i32 0
@@ -212,6 +204,14 @@ _llgo_0:
   ret i64 %2
 }
 
+declare i1 @"github.com/goplus/llgo/runtime/internal/runtime.memequalptr"(ptr, ptr)
+
+define linkonce i1 @"__llgo_stub.github.com/goplus/llgo/runtime/internal/runtime.memequalptr"(ptr %0, ptr %1, ptr %2) {
+_llgo_0:
+  %3 = tail call i1 @"github.com/goplus/llgo/runtime/internal/runtime.memequalptr"(ptr %1, ptr %2)
+  ret i1 %3
+}
+
 declare i1 @"github.com/goplus/llgo/runtime/internal/runtime.structequal"(ptr, ptr, ptr)
 
 declare i1 @"github.com/goplus/llgo/runtime/internal/runtime.memequal64"(ptr, ptr)

cl/_testrt/tpabi/out.ll

@@ -148,6 +148,8 @@ _llgo_0:
   ret void
 }
 
+declare i1 @"github.com/goplus/llgo/runtime/internal/runtime.structequal"(ptr, ptr, ptr)
+
 define linkonce void @"github.com/goplus/llgo/cl/_testrt/tpabi.(*T[string,int]).Demo"(ptr %0) {
 _llgo_0:
   %1 = getelementptr inbounds %"github.com/goplus/llgo/cl/_testrt/tpabi.T[string,int]", ptr %0, i32 0, i32 0
@@ -168,8 +170,6 @@ _llgo_0:
   ret void
 }
 
-declare i1 @"github.com/goplus/llgo/runtime/internal/runtime.structequal"(ptr, ptr, ptr)
-
 declare i1 @"github.com/goplus/llgo/runtime/internal/runtime.memequalptr"(ptr, ptr)
 
 define linkonce i1 @"__llgo_stub.github.com/goplus/llgo/runtime/internal/runtime.memequalptr"(ptr %0, ptr %1, ptr %2) {

cl/_testrt/tpmethod/out.ll

@@ -180,14 +180,6 @@ declare void @"github.com/goplus/llgo/runtime/internal/runtime.PrintByte"(i8)
 
 declare ptr @"github.com/goplus/llgo/runtime/internal/runtime.AllocZ"(i64)
 
-declare i1 @"github.com/goplus/llgo/runtime/internal/runtime.memequalptr"(ptr, ptr)
-
-define linkonce i1 @"__llgo_stub.github.com/goplus/llgo/runtime/internal/runtime.memequalptr"(ptr %0, ptr %1, ptr %2) {
-_llgo_0:
-  %3 = tail call i1 @"github.com/goplus/llgo/runtime/internal/runtime.memequalptr"(ptr %1, ptr %2)
-  ret i1 %3
-}
-
 define linkonce void @"github.com/goplus/llgo/cl/_testrt/tpmethod.(*future[github.com/goplus/llgo/cl/_testrt/tpmethod.Tuple[error]]).Then"(ptr %0, { ptr, ptr } %1) {
 _llgo_0:
   %2 = getelementptr inbounds %"github.com/goplus/llgo/cl/_testrt/tpmethod.future[github.com/goplus/llgo/cl/_testrt/tpmethod.Tuple[error]]", ptr %0, i32 0, i32 0
@@ -198,15 +190,23 @@ _llgo_0:
   ret void
 }
 
+declare i1 @"github.com/goplus/llgo/runtime/internal/runtime.memequalptr"(ptr, ptr)
+
+define linkonce i1 @"__llgo_stub.github.com/goplus/llgo/runtime/internal/runtime.memequalptr"(ptr %0, ptr %1, ptr %2) {
+_llgo_0:
+  %3 = tail call i1 @"github.com/goplus/llgo/runtime/internal/runtime.memequalptr"(ptr %1, ptr %2)
+  ret i1 %3
+}
+
+declare i1 @"github.com/goplus/llgo/runtime/internal/runtime.structequal"(ptr, ptr, ptr)
+
 define linkonce %"github.com/goplus/llgo/runtime/internal/runtime.iface" @"github.com/goplus/llgo/cl/_testrt/tpmethod.(*Tuple[error]).Get"(ptr %0) {
 _llgo_0:
   %1 = load %"github.com/goplus/llgo/cl/_testrt/tpmethod.Tuple[error]", ptr %0, align 8
   %2 = call %"github.com/goplus/llgo/runtime/internal/runtime.iface" @"github.com/goplus/llgo/cl/_testrt/tpmethod.Tuple[error].Get"(%"github.com/goplus/llgo/cl/_testrt/tpmethod.Tuple[error]" %1)
   ret %"github.com/goplus/llgo/runtime/internal/runtime.iface" %2
 }
 
-declare i1 @"github.com/goplus/llgo/runtime/internal/runtime.structequal"(ptr, ptr, ptr)
-
 declare i1 @"github.com/goplus/llgo/runtime/internal/runtime.interequal"(ptr, ptr)
 
 define linkonce i1 @"__llgo_stub.github.com/goplus/llgo/runtime/internal/runtime.interequal"(ptr %0, ptr %1, ptr %2) {

cl/compile.go

@@ -333,8 +333,6 @@ func (p *context) compileFuncDecl(pkg llssa.Package, f *ssa.Function) (llssa.Fun
 			fn.Inline(llssa.NoInline)
 		}
 	}
-	// set compiled to check generic function global instantiation
-	pkg.Prog.SetFuncCompiled(name)
 	isCgo := isCgoExternSymbol(f)
 	if nblk := len(f.Blocks); nblk > 0 {
 		p.cgoCalled = false
@@ -1139,7 +1137,7 @@ func NewPackageEx(prog llssa.Program, patches Patches, rewrites map[string]strin
 	ctx.initPyModule()
 	ctx.initFiles(pkgPath, files, pkgName == "C")
 	ctx.prog.SetPatch(ctx.patchType)
-	ctx.prog.SetCheckRuntimeNamed(ctx.checkRuntimeNamed)
+	ctx.prog.SetCompileMethods(ctx.checkCompileMethods)
 	ret.SetResolveLinkname(ctx.resolveLinkname)
 
 	if hasPatch {
@@ -1352,15 +1350,26 @@ func (p *context) resolveLinkname(name string) string {
 	return name
 }
 
-// checkRuntimeNamed compiles methods for generic type instantiations.
-// Only types with type arguments (instantiated generics) need method compilation
-// here, as non-generic types have their methods compiled elsewhere.
-func (p *context) checkRuntimeNamed(pkg llssa.Package, typ *types.Named) {
-	if typ.TypeArgs() == nil {
-		return
+// checkCompileMethods ensures that all methods attached to the given type
+// (and to the types it refers to) are compiled and emitted into the
+// current SSA package. Generic named types and struct types are the
+// primary targets; pointer types are followed until a non-pointer is
+// reached. non-generic named have their methods compiled elsewhere.
+func (p *context) checkCompileMethods(pkg llssa.Package, typ types.Type) {
+	nt := typ
+retry:
+	switch t := nt.(type) {
+	case *types.Named:
+		if t.TypeArgs() == nil {
+			return
+		}
+		p.compileMethods(pkg, typ)
+	case *types.Struct:
+		p.compileMethods(pkg, typ)
+	case *types.Pointer:
+		nt = t.Elem()
+		goto retry
 	}
-	p.compileMethods(pkg, typ)
-	p.compileMethods(pkg, types.NewPointer(typ))
 }
 
 // -----------------------------------------------------------------------------