cgo: implement support for static functions

Author: aykevl

cgo/cgo.go

@@ -39,12 +39,15 @@ type cgoPackage struct {
 	cflags          []string // CFlags from #cgo lines
 	ldflags         []string // LDFlags from #cgo lines
 	visitedFiles    map[string][]byte
+	cgoHeaders      []string
 }
 
 // cgoFile holds information only for a single Go file (with one or more
 // `import "C"` statements).
 type cgoFile struct {
 	*cgoPackage
+	file    *ast.File
+	index   int
 	defined map[string]ast.Node
 	names   map[string]clangCursor
 }
@@ -210,13 +213,13 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 		}
 	}
 	// Patch some types, for example *C.char in C.CString.
-	cf := p.newCGoFile()
+	cf := p.newCGoFile(nil, -1)
 	astutil.Apply(p.generated, func(cursor *astutil.Cursor) bool {
 		return cf.walker(cursor, nil)
 	}, nil)
 
 	// Find `import "C"` C fragments in the file.
-	cgoHeaders := make([]string, len(files)) // combined CGo header fragment for each file
+	p.cgoHeaders = make([]string, len(files)) // combined CGo header fragment for each file
 	for i, f := range files {
 		var cgoHeader string
 		for i := 0; i < len(f.Decls); i++ {
@@ -275,7 +278,7 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 			cgoHeader += fragment
 		}
 
-		cgoHeaders[i] = cgoHeader
+		p.cgoHeaders[i] = cgoHeader
 	}
 
 	// Define CFlags that will be used while parsing the package.
@@ -289,7 +292,7 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 	}
 
 	// Retrieve types such as C.int, C.longlong, etc from C.
-	p.newCGoFile().readNames(builtinAliasTypedefs, cflagsForCGo, "", func(names map[string]clangCursor) {
+	p.newCGoFile(nil, -1).readNames(builtinAliasTypedefs, cflagsForCGo, "", func(names map[string]clangCursor) {
 		gen := &ast.GenDecl{
 			TokPos: token.NoPos,
 			Tok:    token.TYPE,
@@ -303,8 +306,8 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 
 	// Process CGo imports for each file.
 	for i, f := range files {
-		cf := p.newCGoFile()
-		cf.readNames(cgoHeaders[i], cflagsForCGo, filepath.Base(fset.File(f.Pos()).Name()), func(names map[string]clangCursor) {
+		cf := p.newCGoFile(f, i)
+		cf.readNames(p.cgoHeaders[i], cflagsForCGo, filepath.Base(fset.File(f.Pos()).Name()), func(names map[string]clangCursor) {
 			for _, name := range builtinAliases {
 				// Names such as C.int should not be obtained from C.
 				// This works around an issue in picolibc that has `#define int`
@@ -320,12 +323,14 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 	// Print the newly generated in-memory AST, for debugging.
 	//ast.Print(fset, p.generated)
 
-	return p.generated, cgoHeaders, p.cflags, p.ldflags, p.visitedFiles, p.errors
+	return p.generated, p.cgoHeaders, p.cflags, p.ldflags, p.visitedFiles, p.errors
 }
 
-func (p *cgoPackage) newCGoFile() *cgoFile {
+func (p *cgoPackage) newCGoFile(file *ast.File, index int) *cgoFile {
 	return &cgoFile{
 		cgoPackage: p,
+		file:       file,
+		index:      index,
 		defined:    make(map[string]ast.Node),
 		names:      make(map[string]clangCursor),
 	}
@@ -1117,8 +1122,11 @@ func (f *cgoFile) getASTDeclName(name string, found clangCursor, iscall bool) st
 		return alias
 	}
 	node := f.getASTDeclNode(name, found, iscall)
-	if _, ok := node.(*ast.FuncDecl); ok && !iscall {
-		return "C." + name + "$funcaddr"
+	if node, ok := node.(*ast.FuncDecl); ok {
+		if !iscall {
+			return node.Name.Name + "$funcaddr"
+		}
+		return node.Name.Name
 	}
 	return "C." + name
 }
@@ -1142,7 +1150,7 @@ func (f *cgoFile) getASTDeclNode(name string, found clangCursor, iscall bool) as
 			// Original cgo reports an error like
 			//   cgo: inconsistent definitions for C.myint
 			// which is far less helpful.
-			f.addError(getPos(node), "defined previously at "+f.fset.Position(getPos(newNode)).String()+" with a different type")
+			f.addError(getPos(node), name+" defined previously at "+f.fset.Position(getPos(newNode)).String()+" with a different type")
 		}
 		f.defined[name] = node
 		return node
@@ -1152,17 +1160,25 @@ func (f *cgoFile) getASTDeclNode(name string, found clangCursor, iscall bool) as
 	f.defined[name] = nil
 	node, elaboratedType := f.createASTNode(name, found)
 	f.defined[name] = node
-	f.definedGlobally[name] = node
 	switch node := node.(type) {
 	case *ast.FuncDecl:
+		if strings.HasPrefix(node.Doc.List[0].Text, "//export _Cgo_static_") {
+			// Static function. Only accessible in the current Go file.
+			globalName := strings.TrimPrefix(node.Doc.List[0].Text, "//export ")
+			aliasDeclaration := fmt.Sprintf("void %s(void) __attribute__((alias(%#v)));", globalName, name)
+			f.cgoHeaders[f.index] += "\n\n" + aliasDeclaration
+		} else {
+			// Regular (non-static) function.
+			f.definedGlobally[name] = node
+		}
 		f.generated.Decls = append(f.generated.Decls, node)
 		// Also add a declaration like the following:
 		//   var C.foo$funcaddr unsafe.Pointer
 		f.generated.Decls = append(f.generated.Decls, &ast.GenDecl{
 			Tok: token.VAR,
 			Specs: []ast.Spec{
 				&ast.ValueSpec{
-					Names: []*ast.Ident{{Name: "C." + name + "$funcaddr"}},
+					Names: []*ast.Ident{{Name: node.Name.Name + "$funcaddr"}},
 					Type: &ast.SelectorExpr{
 						X:   &ast.Ident{Name: "unsafe"},
 						Sel: &ast.Ident{Name: "Pointer"},
@@ -1171,8 +1187,10 @@ func (f *cgoFile) getASTDeclNode(name string, found clangCursor, iscall bool) as
 			},
 		})
 	case *ast.GenDecl:
+		f.definedGlobally[name] = node
 		f.generated.Decls = append(f.generated.Decls, node)
 	case *ast.TypeSpec:
+		f.definedGlobally[name] = node
 		f.generated.Decls = append(f.generated.Decls, &ast.GenDecl{
 			Tok:   token.TYPE,
 			Specs: []ast.Spec{node},

cgo/libclang.go

@@ -4,7 +4,9 @@ package cgo
 // modification. It does not touch the AST itself.
 
 import (
+	"crypto/sha256"
 	"crypto/sha512"
+	"encoding/hex"
 	"fmt"
 	"go/ast"
 	"go/scanner"
@@ -47,6 +49,7 @@ CXType tinygo_clang_getTypedefDeclUnderlyingType(GoCXCursor c);
 CXType tinygo_clang_getCursorResultType(GoCXCursor c);
 int tinygo_clang_Cursor_getNumArguments(GoCXCursor c);
 GoCXCursor tinygo_clang_Cursor_getArgument(GoCXCursor c, unsigned i);
+enum CX_StorageClass tinygo_clang_Cursor_getStorageClass(GoCXCursor c);
 CXSourceLocation tinygo_clang_getCursorLocation(GoCXCursor c);
 CXSourceRange tinygo_clang_getCursorExtent(GoCXCursor c);
 CXTranslationUnit tinygo_clang_Cursor_getTranslationUnit(GoCXCursor c);
@@ -187,19 +190,32 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, *elaborat
 			Kind: ast.Fun,
 			Name: "C." + name,
 		}
+		exportName := name
+		localName := name
+		if C.tinygo_clang_Cursor_getStorageClass(c) == C.CX_SC_Static {
+			// A static function is assigned a globally unique symbol name based
+			// on the file path (like _Cgo_static_2d09198adbf58f4f4655_foo) and
+			// has a different Go name in the form of C.foo!symbols.go instead
+			// of just C.foo.
+			path := f.fset.File(f.file.Pos()).Name()
+			staticIDBuf := sha256.Sum256([]byte(path))
+			staticID := hex.EncodeToString(staticIDBuf[:10])
+			exportName = "_Cgo_static_" + staticID + "_" + name
+			localName = name + "!" + filepath.Base(path)
+		}
 		args := make([]*ast.Field, numArgs)
 		decl := &ast.FuncDecl{
 			Doc: &ast.CommentGroup{
 				List: []*ast.Comment{
 					{
 						Slash: pos - 1,
-						Text:  "//export " + name,
+						Text:  "//export " + exportName,
 					},
 				},
 			},
 			Name: &ast.Ident{
 				NamePos: pos,
-				Name:    "C." + name,
+				Name:    "C." + localName,
 				Obj:     obj,
 			},
 			Type: &ast.FuncType{

cgo/libclang_stubs.c

@@ -45,6 +45,10 @@ CXCursor tinygo_clang_Cursor_getArgument(CXCursor c, unsigned i) {
 	return clang_Cursor_getArgument(c, i);
 }
 
+enum CX_StorageClass tinygo_clang_Cursor_getStorageClass(CXCursor c) {
+	return clang_Cursor_getStorageClass(c);
+}
+
 CXSourceLocation tinygo_clang_getCursorLocation(CXCursor c) {
 	return clang_getCursorLocation(c);
 }

cgo/testdata/symbols.go

@@ -5,6 +5,7 @@ package main
 int foo(int a, int b);
 void variadic0();
 void variadic2(int x, int y, ...);
+static void staticfunc(int x);
 
 // Global variable signatures.
 extern int someValue;
@@ -16,6 +17,7 @@ func accessFunctions() {
 	C.foo(3, 4)
 	C.variadic0()
 	C.variadic2(3, 5)
+	C.staticfunc(3)
 }
 
 func accessGlobals() {

cgo/testdata/symbols.out.go

@@ -55,5 +55,10 @@ func C.variadic2(x C.int, y C.int)
 
 var C.variadic2$funcaddr unsafe.Pointer
 
+//export _Cgo_static_2d09198adbf58f4f4655_staticfunc
+func C.staticfunc!symbols.go(x C.int)
+
+var C.staticfunc!symbols.go$funcaddr unsafe.Pointer
+
 //go:extern someValue
 var C.someValue C.int

testdata/cgo/extra.go

@@ -3,4 +3,12 @@ package main
 // Make sure CGo supports multiple files.
 
 // int fortytwo(void);
+// static float headerfunc_static(float a) { return a - 1; }
 import "C"
+
+func headerfunc_2() {
+	// Call headerfunc_static that is different from the headerfunc_static in
+	// the main.go file.
+	// The upstream CGo implementation does not handle this case correctly.
+	println("static headerfunc 2:", C.headerfunc_static(5))
+}

testdata/cgo/main.go

@@ -12,6 +12,7 @@ int mul(int, int);
 import "C"
 
 // int headerfunc(int a) { return a + 1; }
+// static int headerfunc_static(int a) { return a - 1; }
 import "C"
 
 import "unsafe"
@@ -47,6 +48,8 @@ func main() {
 
 	// functions in the header C snippet
 	println("headerfunc:", C.headerfunc(5))
+	println("static headerfunc:", C.headerfunc_static(5))
+	headerfunc_2()
 
 	// equivalent types
 	var goInt8 int8 = 5

testdata/cgo/out.txt

@@ -16,6 +16,8 @@ callback 2: 600
 variadic0: 1
 variadic2: 15
 headerfunc: 6
+static headerfunc: 4
+static headerfunc 2: +4.000000e+000
 bool: true true
 float: +3.100000e+000
 double: +3.200000e+000