ssa: TestAbiTables

Author: visualfc

ssa/abi/abi.go

@@ -75,7 +75,7 @@ func ChanDir(dir types.ChanDir) (abi.ChanDir, string) {
 	case types.RecvOnly:
 		return abi.RecvDir, "<-chan"
 	}
-	panic("invlid chan dir")
+	panic("invalid chan dir")
 }
 
 // -----------------------------------------------------------------------------

ssa/abi/type.go

@@ -7,6 +7,11 @@ import (
 	"github.com/goplus/llgo/runtime/abi"
 )
 
+const (
+	TFlagUncommon   = abi.TFlagUncommon
+	KindDirectIface = abi.KindDirectIface
+)
+
 func (b *Builder) MapBucket(t *types.Map) types.Type {
 	return MapBucketType(t, b.Sizes)
 }

ssa/abitype.go

@@ -75,11 +75,11 @@ func (b Builder) abiCommonFields(t types.Type, name string, hasUncommon bool) (f
 	hash := binary.LittleEndian.Uint32(h[:4])
 	fields = append(fields, prog.IntVal(uint64(hash), prog.Uint32()).impl)
 	// TFlag uint8
-	tflag := uint64(ab.TFlag(t))
+	tflag := ab.TFlag(t)
 	if hasUncommon {
-		tflag |= (1 << 0) // TFlagUncommon
+		tflag |= abi.TFlagUncommon
 	}
-	fields = append(fields, prog.IntVal(tflag, prog.Byte()).impl)
+	fields = append(fields, prog.IntVal(uint64(tflag), prog.Byte()).impl)
 	// Align uint8
 	align := prog.IntVal(uint64(ab.Align(t)), prog.Byte()).impl
 	fields = append(fields, align)
@@ -88,7 +88,7 @@ func (b Builder) abiCommonFields(t types.Type, name string, hasUncommon bool) (f
 	// Kind uint8
 	kind := uint8(ab.Kind(t))
 	if k, _, _ := abi.DataKindOf(t, 0, prog.is32Bits); k != abi.Indirect {
-		kind |= (1 << 5) //KindDirectIface
+		kind |= uint8(abi.KindDirectIface)
 	}
 	fields = append(fields, prog.IntVal(uint64(kind), prog.Byte()).impl)
 	// Equal func(unsafe.Pointer, unsafe.Pointer) bool

ssa/package.go

@@ -168,11 +168,10 @@ type aProgram struct {
 	pyObjPtr  Type
 	pyObjPPtr Type
 
-	abiTy     Type
-	abiTyPtr  Type
-	abiTyPPtr Type
-	deferTy   Type
-	deferPtr  Type
+	abiTy    Type
+	abiTyPtr Type
+	deferTy  Type
+	deferPtr Type
 
 	pyImpTy      *types.Signature
 	pyNewList    *types.Signature
@@ -476,14 +475,6 @@ func (p Program) AbiTypePtr() Type {
 	return p.abiTyPtr
 }
 
-// AbiTypePtrPtr returns **abi.Type type.
-func (p Program) AbiTypePtrPtr() Type {
-	if p.abiTyPPtr == nil {
-		p.abiTyPPtr = p.Pointer(p.AbiTypePtr())
-	}
-	return p.abiTyPPtr
-}
-
 // Void returns void type.
 func (p Program) Void() Type {
 	if p.voidTy == nil {

ssa/ssa_test.go

@@ -1187,3 +1187,64 @@ declare i32 @setjmp(ptr) #0
 attributes #0 = { returns_twice }
 `)
 }
+
+func TestAbiTables(t *testing.T) {
+	prog := NewProgram(nil)
+	prog.sizes = types.SizesFor("gc", runtime.GOARCH)
+	prog.SetRuntime(func() *types.Package {
+		pkg, err := importer.For("source", nil).Import(PkgRuntime)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return pkg
+	})
+	pkg := prog.NewPackage("bar", "foo/bar")
+
+	emptyIface := types.NewInterfaceType(nil, nil)
+	emptyIface.Complete()
+	emptyType := prog.Type(emptyIface, InGo)
+
+	makeFn := func(name string, x Expr) {
+		sig := types.NewSignatureType(nil, nil, nil, nil, types.NewTuple(types.NewVar(0, nil, "", emptyIface)), false)
+		fn := pkg.NewFunc(name, sig, InGo)
+		b := fn.MakeBody(1)
+		iface := b.MakeInterface(emptyType, x)
+		b.Return(iface)
+	}
+
+	makeFn("intIface", prog.Val(1))
+	makeFn("ptrIface", prog.Nil(prog.VoidPtr()))
+	makeFn("floatIface", prog.FloatVal(3.5, prog.Float32()))
+
+	st := types.NewStruct([]*types.Var{
+		types.NewVar(0, nil, "a", types.Typ[types.Int]),
+		types.NewVar(0, nil, "b", types.Typ[types.Int]),
+	}, nil)
+	makeFn("structIface", prog.Zero(prog.Type(st, InGo)))
+
+	single := types.NewStruct([]*types.Var{
+		types.NewVar(0, nil, "v", types.Typ[types.Int]),
+	}, nil)
+	makeFn("singleFieldIface", prog.Zero(prog.Type(single, InGo)))
+
+	pkgTypes := types.NewPackage("foo/bar", "bar")
+	rawSig := types.NewSignatureType(nil, nil, nil, nil, nil, false)
+	rawMeth := types.NewFunc(0, pkgTypes, "M", rawSig)
+	nonEmpty := types.NewInterfaceType([]*types.Func{rawMeth}, nil)
+	nonEmpty.Complete()
+	nonEmptyType := prog.Type(nonEmpty, InGo)
+	sigNE := types.NewSignatureType(nil, nil, nil, nil, types.NewTuple(types.NewVar(0, nil, "", nonEmpty)), false)
+	fnNE := pkg.NewFunc("nonEmptyIface", sigNE, InGo)
+	bNE := fnNE.MakeBody(1)
+	bNE.Return(bNE.MakeInterface(nonEmptyType, prog.Val(7)))
+
+	fn := pkg.InitAbiTypes(pkg.Path() + ".init$abitables")
+	s := fn.impl.String()
+	if !strings.Contains(s, `define void @"foo/bar.init$abitables"() {
+_llgo_0:
+  call void @"github.com/goplus/llgo/runtime/internal/runtime.initTypes"(ptr @"foo/bar.init$abitables$slice")
+  ret void
+}`) {
+		t.Fatal("error abi tables", s)
+	}
+}