compiler: support file-level //go:linkname directives

Modern golang.org/x/sys/unix (v0.36+) declares its linknames
detached from function declarations, e.g.:

    func syscall_syscall(...)
    //go:linkname syscall_syscall syscall.syscall

TinyGo's pragma parser only inspected function doc comments and
therefore missed these, producing link errors like:

    undefined symbol: _golang.org/x/sys/unix.syscall_syscall

Extend parsePragmas to also walk the enclosing *ast.File's
free-standing comments for //go:linkname directives matching the
function's name. Function-attached directives still take
precedence. The existing 'unsafe' import gate is preserved.

Fixes #4395, #5365

compiler/symbol.go

@@ -399,6 +399,51 @@ func (c *compilerContext) parsePragmas(info *functionInfo, f *ssa.Function) {
 		}
 	}
 
+	// Also scan file-level //go:linkname directives. These appear as
+	// free-standing comments in *ast.File.Comments (not attached to any
+	// declaration), and are used by modern golang.org/x/sys/unix and others.
+	// Function-attached directives (above) take precedence — we only add
+	// file-level ones if no doc-comment linkname was found for this function.
+	//
+	// TODO: the hasUnsafeImport gate enforced downstream (see the
+	// //go:linkname case below) is package-level. gc enforces it per
+	// file, on the file containing the directive. For file-level
+	// linknames this is more important than for function-attached ones,
+	// because the directive can live in a file separate from the
+	// function. A stricter implementation would check whether the file
+	// returned by fileForFunc imports "unsafe", not whether any file in
+	// the package does.
+	hasFunctionLinkname := false
+	for _, comment := range pragmas {
+		if strings.HasPrefix(comment.Text, "//go:linkname ") {
+			parts := strings.Fields(comment.Text)
+			if len(parts) == 3 && parts[1] == f.Name() {
+				hasFunctionLinkname = true
+				break
+			}
+		}
+	}
+	if !hasFunctionLinkname {
+		if file := c.fileForFunc(f); file != nil {
+			for _, group := range file.Comments {
+				// Skip the function's own doc comment — already handled above.
+				if decl, ok := syntax.(*ast.FuncDecl); ok && group == decl.Doc {
+					continue
+				}
+				for _, comment := range group.List {
+					if !strings.HasPrefix(comment.Text, "//go:linkname ") {
+						continue
+					}
+					parts := strings.Fields(comment.Text)
+					if len(parts) != 3 || parts[1] != f.Name() {
+						continue
+					}
+					pragmas = append(pragmas, comment)
+				}
+			}
+		}
+	}
+
 	// Parse each pragma.
 	for _, comment := range pragmas {
 		parts := strings.Fields(comment.Text)
@@ -693,6 +738,34 @@ type globalInfo struct {
 	section  string // go:section
 }
 
+// fileForFunc returns the *ast.File that contains the declaration of f, or
+// nil if it cannot be determined. File-level pragmas are only consulted for
+// functions in the package currently being compiled — functions imported from
+// other packages have their file-level pragmas processed when those packages
+// are compiled.
+func (c *compilerContext) fileForFunc(f *ssa.Function) *ast.File {
+	if c.loaderPkg == nil || f.Pkg == nil || f.Pkg.Pkg != c.loaderPkg.Pkg {
+		return nil
+	}
+	syntax := f.Syntax()
+	if f.Origin() != nil {
+		syntax = f.Origin().Syntax()
+	}
+	if syntax == nil {
+		return nil
+	}
+	pos := syntax.Pos()
+	if !pos.IsValid() {
+		return nil
+	}
+	for _, file := range c.loaderPkg.Files {
+		if file.FileStart <= pos && pos < file.FileEnd {
+			return file
+		}
+	}
+	return nil
+}
+
 // loadASTComments loads comments on globals from the AST, for use later in the
 // program. In particular, they are required for //go:extern pragmas on globals.
 func (c *compilerContext) loadASTComments(pkg *loader.Package) {