loader/cgo: add support for function pointers

loader/cgo.go

@@ -130,6 +130,9 @@ func (p *Package) processCgo(filename string, f *ast.File, cflags []string) erro
 	// Declare functions found by libclang.
 	info.addFuncDecls()
 
+	// Declare stub function pointer values found by libclang.
+	info.addFuncPtrDecls()
+
 	// Declare globals found by libclang.
 	info.addVarDecls()
 
@@ -199,6 +202,55 @@ func (info *fileInfo) addFuncDecls() {
 	}
 }
 
+// addFuncPtrDecls creates stub declarations of function pointer values. These
+// values will later be replaced with the real values in the compiler.
+// It adds code like the following to the AST:
+//
+//     var (
+//         C.add unsafe.Pointer
+//         C.mul unsafe.Pointer
+//         // ...
+//     )
+func (info *fileInfo) addFuncPtrDecls() {
+	gen := &ast.GenDecl{
+		TokPos: info.importCPos,
+		Tok:    token.VAR,
+		Lparen: info.importCPos,
+		Rparen: info.importCPos,
+	}
+	names := make([]string, 0, len(info.functions))
+	for name := range info.functions {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		obj := &ast.Object{
+			Kind: ast.Typ,
+			Name: "C." + name + "$funcaddr",
+		}
+		valueSpec := &ast.ValueSpec{
+			Names: []*ast.Ident{&ast.Ident{
+				NamePos: info.importCPos,
+				Name:    "C." + name + "$funcaddr",
+				Obj:     obj,
+			}},
+			Type: &ast.SelectorExpr{
+				X: &ast.Ident{
+					NamePos: info.importCPos,
+					Name:    "unsafe",
+				},
+				Sel: &ast.Ident{
+					NamePos: info.importCPos,
+					Name:    "Pointer",
+				},
+			},
+		}
+		obj.Decl = valueSpec
+		gen.Specs = append(gen.Specs, valueSpec)
+	}
+	info.Decls = append(info.Decls, gen)
+}
+
 // addVarDecls declares external C globals in the Go source.
 // It adds code like the following to the AST:
 //
@@ -327,15 +379,34 @@ func (info *fileInfo) addTypedefs() {
 // separate namespace (no _Cgo_ hacks like in gc).
 func (info *fileInfo) walker(cursor *astutil.Cursor) bool {
 	switch node := cursor.Node().(type) {
+	case *ast.CallExpr:
+		fun, ok := node.Fun.(*ast.SelectorExpr)
+		if !ok {
+			return true
+		}
+		x, ok := fun.X.(*ast.Ident)
+		if !ok {
+			return true
+		}
+		if _, ok := info.functions[fun.Sel.Name]; ok && x.Name == "C" {
+			node.Fun = &ast.Ident{
+				NamePos: x.NamePos,
+				Name:    "C." + fun.Sel.Name,
+			}
+		}
 	case *ast.SelectorExpr:
 		x, ok := node.X.(*ast.Ident)
 		if !ok {
 			return true
 		}
 		if x.Name == "C" {
+			name := "C." + node.Sel.Name
+			if _, ok := info.functions[node.Sel.Name]; ok {
+				name += "$funcaddr"
+			}
 			cursor.Replace(&ast.Ident{
 				NamePos: x.NamePos,
-				Name:    "C." + node.Sel.Name,
+				Name:    name,
 			})
 		}
 	}

loader/libclang.go

@@ -6,6 +6,8 @@ package loader
 import (
 	"errors"
 	"go/ast"
+	"go/token"
+	"strconv"
 	"strings"
 	"unsafe"
 )
@@ -90,13 +92,16 @@ func tinygo_clang_visitor(c, parent C.CXCursor, client_data C.CXClientData) C.in
 		if C.clang_isFunctionTypeVariadic(cursorType) != 0 {
 			return C.CXChildVisit_Continue // not supported
 		}
-		numArgs := C.clang_Cursor_getNumArguments(c)
+		numArgs := int(C.clang_Cursor_getNumArguments(c))
 		fn := &functionInfo{}
 		info.functions[name] = fn
-		for i := C.int(0); i < numArgs; i++ {
+		for i := 0; i < numArgs; i++ {
 			arg := C.clang_Cursor_getArgument(c, C.uint(i))
 			argName := getString(C.clang_getCursorSpelling(arg))
 			argType := C.clang_getArgType(cursorType, C.uint(i))
+			if argName == "" {
+				argName = "$" + strconv.Itoa(i)
+			}
 			fn.args = append(fn.args, paramInfo{
 				name:     argName,
 				typeExpr: info.makeASTType(argType),
@@ -196,6 +201,23 @@ func (info *fileInfo) makeASTType(typ C.CXType) ast.Expr {
 			Star: info.importCPos,
 			X:    info.makeASTType(C.clang_getPointeeType(typ)),
 		}
+	case C.CXType_FunctionProto:
+		// Be compatible with gc, which uses the *[0]byte type for function
+		// pointer types.
+		// Return type [0]byte because this is a function type, not a pointer to
+		// this function type.
+		return &ast.ArrayType{
+			Lbrack: info.importCPos,
+			Len: &ast.BasicLit{
+				ValuePos: info.importCPos,
+				Kind:     token.INT,
+				Value:    "0",
+			},
+			Elt: &ast.Ident{
+				NamePos: info.importCPos,
+				Name:    "byte",
+			},
+		}
 	default:
 		// Fallback, probably incorrect but at least the error points to an odd
 		// type name.