remove abi.Name

ssa/cl_test.go

@@ -26,7 +26,7 @@ import (
 )
 
 func TestFromTestgo(t *testing.T) {
-	cltest.FromDir(t, "strucintf", "../cl/_testgo", false)
+	cltest.FromDir(t, "", "../cl/_testgo", false)
 }
 
 func TestFromTestpy(t *testing.T) {

ssa/expr.go

@@ -91,6 +91,8 @@ func (p Program) Zero(t Type) Expr {
 			flds[i] = p.Zero(p.rawType(u.Field(i).Type())).impl
 		}
 		ret = llvm.ConstStruct(flds, false)
+	case *types.Slice:
+		ret = p.Zero(p.rtType("Slice")).impl
 	default:
 		log.Panicln("todo:", u)
 	}
@@ -193,7 +195,8 @@ func (b Builder) Str(v string) (ret Expr) {
 
 func (b Builder) pkgName(pkgPath string) Expr {
 	// TODO(xsw): use a global cache
-	return b.Call(b.Pkg.rtFunc("NewPkgName"), b.Str(pkgPath))
+	// return b.Call(b.Pkg.rtFunc("NewPkgName"), b.Str(pkgPath))
+	return b.Str(pkgPath)
 }
 
 // unsafeString(data *byte, size int) string
@@ -513,38 +516,42 @@ func llvmPredBlocks(preds []BasicBlock) []llvm.BasicBlock {
 
 type aPhi struct {
 	Expr
-	phis []llvm.Value
+	// phis []llvm.Value
 }
 
 // Phi represents a phi node.
 type Phi = *aPhi
 
+/*
 func (b Builder) newPhi(t Type, phis []llvm.Value) Phi {
 	ret := b.aggregateValue(t, phis...)
 	return &aPhi{ret, phis}
 }
+*/
 
 // AddIncoming adds incoming values to a phi node.
 func (p Phi) AddIncoming(b Builder, preds []BasicBlock, f func(i int, blk BasicBlock) Expr) {
 	bs := llvmPredBlocks(preds)
-	phis := p.phis
-	if phis != nil {
-		vals := make([][]llvm.Value, len(phis))
-		for iblk, blk := range preds {
-			val := f(iblk, blk).impl
-			impl := b.impl
-			b.SetBlockEx(blk, BeforeLast, false)
-			for i := range phis {
-				if iblk == 0 {
-					vals[i] = make([]llvm.Value, len(preds))
+	/*
+		phis := p.phis
+		if phis != nil {
+			vals := make([][]llvm.Value, len(phis))
+			for iblk, blk := range preds {
+				val := f(iblk, blk).impl
+				impl := b.impl
+				b.SetBlockEx(blk, BeforeLast, false)
+				for i := range phis {
+					if iblk == 0 {
+						vals[i] = make([]llvm.Value, len(preds))
+					}
+					vals[i][iblk] = llvm.CreateExtractValue(impl, val, i)
 				}
-				vals[i][iblk] = llvm.CreateExtractValue(impl, val, i)
 			}
-		}
-		for i, phi := range phis {
-			phi.AddIncoming(vals[i], bs)
-		}
-	} else {
+			for i, phi := range phis {
+				phi.AddIncoming(vals[i], bs)
+			}
+		} else */
+	{
 		vals := make([]llvm.Value, len(preds))
 		for iblk, blk := range preds {
 			vals[iblk] = f(iblk, blk).impl
@@ -556,24 +563,27 @@ func (p Phi) AddIncoming(b Builder, preds []BasicBlock, f func(i int, blk BasicB
 // Phi returns a phi node.
 func (b Builder) Phi(t Type) Phi {
 	impl := b.impl
-	switch tund := t.raw.Type.Underlying().(type) {
-	case *types.Basic:
-		kind := tund.Kind()
-		switch kind {
-		case types.String:
-			phis := createStringPhis(impl, make([]llvm.Value, 0, 2), b.Prog)
+	/*
+		switch tund := t.raw.Type.Underlying().(type) {
+		case *types.Basic:
+			kind := tund.Kind()
+			switch kind {
+			case types.String:
+				phis := createStringPhis(impl, make([]llvm.Value, 0, 2), b.Prog)
+				return b.newPhi(t, phis)
+			}
+		case *types.Struct:
+			phis := createStrucPhis(impl, nil, tund, b.Prog)
 			return b.newPhi(t, phis)
+		default:
+			log.Panicf("todo: %T\n", tund)
 		}
-	case *types.Struct:
-		phis := createStrucPhis(impl, nil, tund, b.Prog)
-		return b.newPhi(t, phis)
-	default:
-		log.Panicf("todo: %T\n", tund)
-	}
+	*/
 	phi := llvm.CreatePHI(impl, t.ll)
-	return &aPhi{Expr{phi, t}, nil}
+	return &aPhi{Expr{phi, t}} //, nil}
 }
 
+/*
 func createStringPhis(b llvm.Builder, phis []llvm.Value, prog Program) []llvm.Value {
 	phis = append(phis, llvm.CreatePHI(b, prog.tyVoidPtr()))
 	return append(phis, llvm.CreatePHI(b, prog.tyInt()))
@@ -611,6 +621,7 @@ func createBasicPhi(b llvm.Builder, phis []llvm.Value, t types.Type, prog Progra
 	phi := llvm.CreatePHI(b, tll)
 	return append(phis, phi)
 }
+*/
 
 // -----------------------------------------------------------------------------
 

ssa/interface.go

@@ -59,10 +59,19 @@ func (b Builder) abiTypeOf(t types.Type) Expr {
 	panic("todo")
 }
 
+// func Named(pkgPath, name string, underlying *Type, methods []abi.Method)
 func (b Builder) abiNamedOf(t *types.Named) Expr {
 	under := b.abiTypeOf(t.Underlying())
 	name := NameOf(t)
-	return b.Call(b.Pkg.rtFunc("Named"), b.Str(name), under)
+
+	prog := b.Prog
+	pkg := b.Pkg
+	pkgPath := b.pkgName(pkg.Path())
+	fn := pkg.rtFunc("Named")
+	tSlice := lastParamType(prog, fn)
+	// TODO(xsw): methods
+	methods := prog.Zero(tSlice)
+	return b.Call(fn, pkgPath, b.Str(name), under, methods)
 }
 
 func (b Builder) abiPointerOf(t *types.Pointer) Expr {
@@ -70,7 +79,7 @@ func (b Builder) abiPointerOf(t *types.Pointer) Expr {
 	return b.Call(b.Pkg.rtFunc("Pointer"), elem)
 }
 
-// func Struct(size uintptr, pkgPath string, fields []abi.StructField) *abi.Type
+// func Struct(pkgPath string, size uintptr, fields []abi.StructField)
 func (b Builder) abiStructOf(t *types.Struct) Expr {
 	pkg := b.Pkg
 	prog := b.Prog
@@ -85,20 +94,23 @@ func (b Builder) abiStructOf(t *types.Struct) Expr {
 		flds[i] = b.structField(sfAbi, prog, f, off, t.Tag(i))
 	}
 	pkgPath := b.pkgName(pkg.Path())
-	params := strucAbi.raw.Type.(*types.Signature).Params()
-	tSlice := prog.rawType(params.At(params.Len() - 1).Type().(*types.Slice))
+	tSlice := lastParamType(prog, strucAbi)
 	fldSlice := b.SliceLit(tSlice, flds...)
 	size := prog.IntVal(prog.SizeOf(typ), prog.Uintptr())
 	return b.Call(strucAbi, pkgPath, size, fldSlice)
 }
 
-// func StructField(name string, typ *abi.Type, off uintptr, tag string, exported, embedded bool) abi.StructField
+func lastParamType(prog Program, fn Expr) Type {
+	params := fn.raw.Type.(*types.Signature).Params()
+	return prog.rawType(params.At(params.Len() - 1).Type())
+}
+
+// func StructField(name string, typ *abi.Type, off uintptr, tag string, embedded bool) abi.StructField
 func (b Builder) structField(sfAbi Expr, prog Program, f *types.Var, offset uintptr, tag string) Expr {
 	name := b.Str(f.Name())
 	typ := b.abiType(f.Type())
-	exported := prog.Val(f.Exported())
 	embedded := prog.Val(f.Embedded())
-	return b.Call(sfAbi, name, typ, prog.Val(offset), b.Str(tag), exported, embedded)
+	return b.Call(sfAbi, name, typ, prog.Val(offset), b.Str(tag), embedded)
 }
 
 // abiType returns the abi type of the specified type.