llgo/ssa: pkg.NewFunc bugfix

ssa/package.go

@@ -187,7 +187,7 @@ func (p Program) NewPackage(name, pkgPath string) Package {
 	// mod.Finalize()
 	fns := make(map[string]Function)
 	gbls := make(map[string]Global)
-	return &aPackage{mod, fns, gbls, p, nil}
+	return &aPackage{mod, fns, gbls, p}
 }
 
 // Void returns void type.
@@ -267,8 +267,6 @@ type aPackage struct {
 	fns  map[string]Function
 	vars map[string]Global
 	prog Program
-
-	abort Function
 }
 
 type Package = *aPackage
@@ -294,6 +292,9 @@ func (p Package) VarOf(name string) Global {
 
 // NewFunc creates a new function.
 func (p Package) NewFunc(name string, sig *types.Signature) Function {
+	if v, ok := p.fns[name]; ok {
+		return v
+	}
 	t := p.prog.llvmSignature(sig)
 	fn := llvm.AddFunction(p.mod, name, t.ll)
 	ret := newFunction(fn, t, p, p.prog)
@@ -306,21 +307,14 @@ func (p Package) FuncOf(name string) Function {
 	return p.fns[name]
 }
 
-func (p Package) rtAbort() Function {
-	if p.abort == nil {
-		p.abort = p.NewFunc("abort", types.NewSignatureType(nil, nil, nil, nil, nil, false))
-	}
-	return p.abort
+func (p Package) rtAbort() Expr {
+	return p.NewFunc("abort", types.NewSignatureType(nil, nil, nil, nil, nil, false)).Expr
 }
 
 func (p Package) rtFunc(fnName string) Expr {
 	fn := p.prog.runtime().Lookup(fnName).(*types.Func)
 	name := FullName(fn.Pkg(), fnName)
-	v, ok := p.fns[name]
-	if !ok {
-		v = p.NewFunc(name, fn.Type().(*types.Signature))
-	}
-	return v.Expr
+	return p.NewFunc(name, fn.Type().(*types.Signature)).Expr
 }
 
 // -----------------------------------------------------------------------------

ssa/stmt_builder.go

@@ -74,7 +74,7 @@ func (b Builder) Panic(v Expr) {
 		log.Printf("Panic %v\n", v.impl)
 	}
 	pkg := b.fn.pkg
-	b.Call(pkg.rtAbort().Expr)
+	b.Call(pkg.rtAbort()) // TODO(xsw): pass v
 }
 
 // Return emits a return instruction.

ssa/type.go

@@ -123,6 +123,9 @@ func (p Program) Field(typ Type, i int) Type {
 }
 
 func (p Program) Type(typ types.Type) Type {
+	if sig, ok := typ.(*types.Signature); ok { // should methodToFunc
+		return p.llvmSignature(sig)
+	}
 	if v := p.typs.At(typ); v != nil {
 		return v.(Type)
 	}
@@ -253,8 +256,6 @@ func (p Program) toLLVMType(typ types.Type) Type {
 		return p.toLLVMStruct(t)
 	case *types.Named:
 		return p.toLLVMNamed(t)
-	case *types.Signature:
-		return p.toLLVMFunc(t)
 	case *types.Array:
 		elem := p.Type(t.Elem())
 		return &aType{llvm.ArrayType(elem.ll, int(t.Len())), typ, vkInvalid}