Source file src/cmd/cgo/out.go

Documentation: cmd/cgo

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package main
     6  
     7  import (
     8  	"bytes"
     9  	"debug/elf"
    10  	"debug/macho"
    11  	"debug/pe"
    12  	"fmt"
    13  	"go/ast"
    14  	"go/printer"
    15  	"go/token"
    16  	"internal/xcoff"
    17  	"io"
    18  	"io/ioutil"
    19  	"os"
    20  	"os/exec"
    21  	"path/filepath"
    22  	"regexp"
    23  	"sort"
    24  	"strings"
    25  )
    26  
    27  var (
    28  	conf         = printer.Config{Mode: printer.SourcePos, Tabwidth: 8}
    29  	noSourceConf = printer.Config{Tabwidth: 8}
    30  )
    31  
    32  // writeDefs creates output files to be compiled by gc and gcc.
    33  func (p *Package) writeDefs() {
    34  	var fgo2, fc io.Writer
    35  	f := creat(*objDir + "_cgo_gotypes.go")
    36  	defer f.Close()
    37  	fgo2 = f
    38  	if *gccgo {
    39  		f := creat(*objDir + "_cgo_defun.c")
    40  		defer f.Close()
    41  		fc = f
    42  	}
    43  	fm := creat(*objDir + "_cgo_main.c")
    44  
    45  	var gccgoInit bytes.Buffer
    46  
    47  	fflg := creat(*objDir + "_cgo_flags")
    48  	for k, v := range p.CgoFlags {
    49  		fmt.Fprintf(fflg, "_CGO_%s=%s\n", k, strings.Join(v, " "))
    50  		if k == "LDFLAGS" && !*gccgo {
    51  			for _, arg := range v {
    52  				fmt.Fprintf(fgo2, "//go:cgo_ldflag %q\n", arg)
    53  			}
    54  		}
    55  	}
    56  	fflg.Close()
    57  
    58  	// Write C main file for using gcc to resolve imports.
    59  	fmt.Fprintf(fm, "int main() { return 0; }\n")
    60  	if *importRuntimeCgo {
    61  		fmt.Fprintf(fm, "void crosscall2(void(*fn)(void*, int, __SIZE_TYPE__), void *a, int c, __SIZE_TYPE__ ctxt) { }\n")
    62  		fmt.Fprintf(fm, "__SIZE_TYPE__ _cgo_wait_runtime_init_done(void) { return 0; }\n")
    63  		fmt.Fprintf(fm, "void _cgo_release_context(__SIZE_TYPE__ ctxt) { }\n")
    64  		fmt.Fprintf(fm, "char* _cgo_topofstack(void) { return (char*)0; }\n")
    65  	} else {
    66  		// If we're not importing runtime/cgo, we *are* runtime/cgo,
    67  		// which provides these functions. We just need a prototype.
    68  		fmt.Fprintf(fm, "void crosscall2(void(*fn)(void*, int, __SIZE_TYPE__), void *a, int c, __SIZE_TYPE__ ctxt);\n")
    69  		fmt.Fprintf(fm, "__SIZE_TYPE__ _cgo_wait_runtime_init_done(void);\n")
    70  		fmt.Fprintf(fm, "void _cgo_release_context(__SIZE_TYPE__);\n")
    71  	}
    72  	fmt.Fprintf(fm, "void _cgo_allocate(void *a, int c) { }\n")
    73  	fmt.Fprintf(fm, "void _cgo_panic(void *a, int c) { }\n")
    74  	fmt.Fprintf(fm, "void _cgo_reginit(void) { }\n")
    75  
    76  	// Write second Go output: definitions of _C_xxx.
    77  	// In a separate file so that the import of "unsafe" does not
    78  	// pollute the original file.
    79  	fmt.Fprintf(fgo2, "// Code generated by cmd/cgo; DO NOT EDIT.\n\n")
    80  	fmt.Fprintf(fgo2, "package %s\n\n", p.PackageName)
    81  	fmt.Fprintf(fgo2, "import \"unsafe\"\n\n")
    82  	if !*gccgo && *importRuntimeCgo {
    83  		fmt.Fprintf(fgo2, "import _ \"runtime/cgo\"\n\n")
    84  	}
    85  	if *importSyscall {
    86  		fmt.Fprintf(fgo2, "import \"syscall\"\n\n")
    87  		fmt.Fprintf(fgo2, "var _ syscall.Errno\n")
    88  	}
    89  	fmt.Fprintf(fgo2, "func _Cgo_ptr(ptr unsafe.Pointer) unsafe.Pointer { return ptr }\n\n")
    90  
    91  	if !*gccgo {
    92  		fmt.Fprintf(fgo2, "//go:linkname _Cgo_always_false runtime.cgoAlwaysFalse\n")
    93  		fmt.Fprintf(fgo2, "var _Cgo_always_false bool\n")
    94  		fmt.Fprintf(fgo2, "//go:linkname _Cgo_use runtime.cgoUse\n")
    95  		fmt.Fprintf(fgo2, "func _Cgo_use(interface{})\n")
    96  	}
    97  
    98  	typedefNames := make([]string, 0, len(typedef))
    99  	for name := range typedef {
   100  		typedefNames = append(typedefNames, name)
   101  	}
   102  	sort.Strings(typedefNames)
   103  	for _, name := range typedefNames {
   104  		def := typedef[name]
   105  		fmt.Fprintf(fgo2, "type %s ", name)
   106  		// We don't have source info for these types, so write them out without source info.
   107  		// Otherwise types would look like:
   108  		//
   109  		// type _Ctype_struct_cb struct {
   110  		// //line :1
   111  		//        on_test *[0]byte
   112  		// //line :1
   113  		// }
   114  		//
   115  		// Which is not useful. Moreover we never override source info,
   116  		// so subsequent source code uses the same source info.
   117  		// Moreover, empty file name makes compile emit no source debug info at all.
   118  		var buf bytes.Buffer
   119  		noSourceConf.Fprint(&buf, fset, def.Go)
   120  		if bytes.HasPrefix(buf.Bytes(), []byte("_Ctype_")) {
   121  			// This typedef is of the form `typedef a b` and should be an alias.
   122  			fmt.Fprintf(fgo2, "= ")
   123  		}
   124  		fmt.Fprintf(fgo2, "%s", buf.Bytes())
   125  		fmt.Fprintf(fgo2, "\n\n")
   126  	}
   127  	if *gccgo {
   128  		fmt.Fprintf(fgo2, "type _Ctype_void byte\n")
   129  	} else {
   130  		fmt.Fprintf(fgo2, "type _Ctype_void [0]byte\n")
   131  	}
   132  
   133  	if *gccgo {
   134  		fmt.Fprint(fgo2, gccgoGoProlog)
   135  		fmt.Fprint(fc, p.cPrologGccgo())
   136  	} else {
   137  		fmt.Fprint(fgo2, goProlog)
   138  	}
   139  
   140  	if fc != nil {
   141  		fmt.Fprintf(fc, "#line 1 \"cgo-generated-wrappers\"\n")
   142  	}
   143  	if fm != nil {
   144  		fmt.Fprintf(fm, "#line 1 \"cgo-generated-wrappers\"\n")
   145  	}
   146  
   147  	gccgoSymbolPrefix := p.gccgoSymbolPrefix()
   148  
   149  	cVars := make(map[string]bool)
   150  	for _, key := range nameKeys(p.Name) {
   151  		n := p.Name[key]
   152  		if !n.IsVar() {
   153  			continue
   154  		}
   155  
   156  		if !cVars[n.C] {
   157  			if *gccgo {
   158  				fmt.Fprintf(fc, "extern byte *%s;\n", n.C)
   159  			} else {
   160  				fmt.Fprintf(fm, "extern char %s[];\n", n.C)
   161  				fmt.Fprintf(fm, "void *_cgohack_%s = %s;\n\n", n.C, n.C)
   162  				fmt.Fprintf(fgo2, "//go:linkname __cgo_%s %s\n", n.C, n.C)
   163  				fmt.Fprintf(fgo2, "//go:cgo_import_static %s\n", n.C)
   164  				fmt.Fprintf(fgo2, "var __cgo_%s byte\n", n.C)
   165  			}
   166  			cVars[n.C] = true
   167  		}
   168  
   169  		var node ast.Node
   170  		if n.Kind == "var" {
   171  			node = &ast.StarExpr{X: n.Type.Go}
   172  		} else if n.Kind == "fpvar" {
   173  			node = n.Type.Go
   174  		} else {
   175  			panic(fmt.Errorf("invalid var kind %q", n.Kind))
   176  		}
   177  		if *gccgo {
   178  			fmt.Fprintf(fc, `extern void *%s __asm__("%s.%s");`, n.Mangle, gccgoSymbolPrefix, n.Mangle)
   179  			fmt.Fprintf(&gccgoInit, "\t%s = &%s;\n", n.Mangle, n.C)
   180  			fmt.Fprintf(fc, "\n")
   181  		}
   182  
   183  		fmt.Fprintf(fgo2, "var %s ", n.Mangle)
   184  		conf.Fprint(fgo2, fset, node)
   185  		if !*gccgo {
   186  			fmt.Fprintf(fgo2, " = (")
   187  			conf.Fprint(fgo2, fset, node)
   188  			fmt.Fprintf(fgo2, ")(unsafe.Pointer(&__cgo_%s))", n.C)
   189  		}
   190  		fmt.Fprintf(fgo2, "\n")
   191  	}
   192  	if *gccgo {
   193  		fmt.Fprintf(fc, "\n")
   194  	}
   195  
   196  	for _, key := range nameKeys(p.Name) {
   197  		n := p.Name[key]
   198  		if n.Const != "" {
   199  			fmt.Fprintf(fgo2, "const %s = %s\n", n.Mangle, n.Const)
   200  		}
   201  	}
   202  	fmt.Fprintf(fgo2, "\n")
   203  
   204  	callsMalloc := false
   205  	for _, key := range nameKeys(p.Name) {
   206  		n := p.Name[key]
   207  		if n.FuncType != nil {
   208  			p.writeDefsFunc(fgo2, n, &callsMalloc)
   209  		}
   210  	}
   211  
   212  	fgcc := creat(*objDir + "_cgo_export.c")
   213  	fgcch := creat(*objDir + "_cgo_export.h")
   214  	if *gccgo {
   215  		p.writeGccgoExports(fgo2, fm, fgcc, fgcch)
   216  	} else {
   217  		p.writeExports(fgo2, fm, fgcc, fgcch)
   218  	}
   219  
   220  	if callsMalloc && !*gccgo {
   221  		fmt.Fprint(fgo2, strings.Replace(cMallocDefGo, "PREFIX", cPrefix, -1))
   222  		fmt.Fprint(fgcc, strings.Replace(strings.Replace(cMallocDefC, "PREFIX", cPrefix, -1), "PACKED", p.packedAttribute(), -1))
   223  	}
   224  
   225  	if err := fgcc.Close(); err != nil {
   226  		fatalf("%s", err)
   227  	}
   228  	if err := fgcch.Close(); err != nil {
   229  		fatalf("%s", err)
   230  	}
   231  
   232  	if *exportHeader != "" && len(p.ExpFunc) > 0 {
   233  		fexp := creat(*exportHeader)
   234  		fgcch, err := os.Open(*objDir + "_cgo_export.h")
   235  		if err != nil {
   236  			fatalf("%s", err)
   237  		}
   238  		_, err = io.Copy(fexp, fgcch)
   239  		if err != nil {
   240  			fatalf("%s", err)
   241  		}
   242  		if err = fexp.Close(); err != nil {
   243  			fatalf("%s", err)
   244  		}
   245  	}
   246  
   247  	init := gccgoInit.String()
   248  	if init != "" {
   249  		// The init function does nothing but simple
   250  		// assignments, so it won't use much stack space, so
   251  		// it's OK to not split the stack. Splitting the stack
   252  		// can run into a bug in clang (as of 2018-11-09):
   253  		// this is a leaf function, and when clang sees a leaf
   254  		// function it won't emit the split stack prologue for
   255  		// the function. However, if this function refers to a
   256  		// non-split-stack function, which will happen if the
   257  		// cgo code refers to a C function not compiled with
   258  		// -fsplit-stack, then the linker will think that it
   259  		// needs to adjust the split stack prologue, but there
   260  		// won't be one. Marking the function explicitly
   261  		// no_split_stack works around this problem by telling
   262  		// the linker that it's OK if there is no split stack
   263  		// prologue.
   264  		fmt.Fprintln(fc, "static void init(void) __attribute__ ((constructor, no_split_stack));")
   265  		fmt.Fprintln(fc, "static void init(void) {")
   266  		fmt.Fprint(fc, init)
   267  		fmt.Fprintln(fc, "}")
   268  	}
   269  }
   270  
   271  // elfImportedSymbols is like elf.File.ImportedSymbols, but it
   272  // includes weak symbols.
   273  //
   274  // A bug in some versions of LLD (at least LLD 8) cause it to emit
   275  // several pthreads symbols as weak, but we need to import those. See
   276  // issue #31912 or https://bugs.llvm.org/show_bug.cgi?id=42442.
   277  //
   278  // When doing external linking, we hand everything off to the external
   279  // linker, which will create its own dynamic symbol tables. For
   280  // internal linking, this may turn weak imports into strong imports,
   281  // which could cause dynamic linking to fail if a symbol really isn't
   282  // defined. However, the standard library depends on everything it
   283  // imports, and this is the primary use of dynamic symbol tables with
   284  // internal linking.
   285  func elfImportedSymbols(f *elf.File) []elf.ImportedSymbol {
   286  	syms, _ := f.DynamicSymbols()
   287  	var imports []elf.ImportedSymbol
   288  	for _, s := range syms {
   289  		if (elf.ST_BIND(s.Info) == elf.STB_GLOBAL || elf.ST_BIND(s.Info) == elf.STB_WEAK) && s.Section == elf.SHN_UNDEF {
   290  			imports = append(imports, elf.ImportedSymbol{
   291  				Name:    s.Name,
   292  				Library: s.Library,
   293  				Version: s.Version,
   294  			})
   295  		}
   296  	}
   297  	return imports
   298  }
   299  
   300  func dynimport(obj string) {
   301  	stdout := os.Stdout
   302  	if *dynout != "" {
   303  		f, err := os.Create(*dynout)
   304  		if err != nil {
   305  			fatalf("%s", err)
   306  		}
   307  		stdout = f
   308  	}
   309  
   310  	fmt.Fprintf(stdout, "package %s\n", *dynpackage)
   311  
   312  	if f, err := elf.Open(obj); err == nil {
   313  		if *dynlinker {
   314  			// Emit the cgo_dynamic_linker line.
   315  			if sec := f.Section(".interp"); sec != nil {
   316  				if data, err := sec.Data(); err == nil && len(data) > 1 {
   317  					// skip trailing \0 in data
   318  					fmt.Fprintf(stdout, "//go:cgo_dynamic_linker %q\n", string(data[:len(data)-1]))
   319  				}
   320  			}
   321  		}
   322  		sym := elfImportedSymbols(f)
   323  		for _, s := range sym {
   324  			targ := s.Name
   325  			if s.Version != "" {
   326  				targ += "#" + s.Version
   327  			}
   328  			fmt.Fprintf(stdout, "//go:cgo_import_dynamic %s %s %q\n", s.Name, targ, s.Library)
   329  		}
   330  		lib, _ := f.ImportedLibraries()
   331  		for _, l := range lib {
   332  			fmt.Fprintf(stdout, "//go:cgo_import_dynamic _ _ %q\n", l)
   333  		}
   334  		return
   335  	}
   336  
   337  	if f, err := macho.Open(obj); err == nil {
   338  		sym, _ := f.ImportedSymbols()
   339  		for _, s := range sym {
   340  			if len(s) > 0 && s[0] == '_' {
   341  				s = s[1:]
   342  			}
   343  			fmt.Fprintf(stdout, "//go:cgo_import_dynamic %s %s %q\n", s, s, "")
   344  		}
   345  		lib, _ := f.ImportedLibraries()
   346  		for _, l := range lib {
   347  			fmt.Fprintf(stdout, "//go:cgo_import_dynamic _ _ %q\n", l)
   348  		}
   349  		return
   350  	}
   351  
   352  	if f, err := pe.Open(obj); err == nil {
   353  		sym, _ := f.ImportedSymbols()
   354  		for _, s := range sym {
   355  			ss := strings.Split(s, ":")
   356  			name := strings.Split(ss[0], "@")[0]
   357  			fmt.Fprintf(stdout, "//go:cgo_import_dynamic %s %s %q\n", name, ss[0], strings.ToLower(ss[1]))
   358  		}
   359  		return
   360  	}
   361  
   362  	if f, err := xcoff.Open(obj); err == nil {
   363  		sym, err := f.ImportedSymbols()
   364  		if err != nil {
   365  			fatalf("cannot load imported symbols from XCOFF file %s: %v", obj, err)
   366  		}
   367  		for _, s := range sym {
   368  			if s.Name == "runtime_rt0_go" || s.Name == "_rt0_ppc64_aix_lib" {
   369  				// These symbols are imported by runtime/cgo but
   370  				// must not be added to _cgo_import.go as there are
   371  				// Go symbols.
   372  				continue
   373  			}
   374  			fmt.Fprintf(stdout, "//go:cgo_import_dynamic %s %s %q\n", s.Name, s.Name, s.Library)
   375  		}
   376  		lib, err := f.ImportedLibraries()
   377  		if err != nil {
   378  			fatalf("cannot load imported libraries from XCOFF file %s: %v", obj, err)
   379  		}
   380  		for _, l := range lib {
   381  			fmt.Fprintf(stdout, "//go:cgo_import_dynamic _ _ %q\n", l)
   382  		}
   383  		return
   384  	}
   385  
   386  	fatalf("cannot parse %s as ELF, Mach-O, PE or XCOFF", obj)
   387  }
   388  
   389  // Construct a gcc struct matching the gc argument frame.
   390  // Assumes that in gcc, char is 1 byte, short 2 bytes, int 4 bytes, long long 8 bytes.
   391  // These assumptions are checked by the gccProlog.
   392  // Also assumes that gc convention is to word-align the
   393  // input and output parameters.
   394  func (p *Package) structType(n *Name) (string, int64) {
   395  	var buf bytes.Buffer
   396  	fmt.Fprint(&buf, "struct {\n")
   397  	off := int64(0)
   398  	for i, t := range n.FuncType.Params {
   399  		if off%t.Align != 0 {
   400  			pad := t.Align - off%t.Align
   401  			fmt.Fprintf(&buf, "\t\tchar __pad%d[%d];\n", off, pad)
   402  			off += pad
   403  		}
   404  		c := t.Typedef
   405  		if c == "" {
   406  			c = t.C.String()
   407  		}
   408  		fmt.Fprintf(&buf, "\t\t%s p%d;\n", c, i)
   409  		off += t.Size
   410  	}
   411  	if off%p.PtrSize != 0 {
   412  		pad := p.PtrSize - off%p.PtrSize
   413  		fmt.Fprintf(&buf, "\t\tchar __pad%d[%d];\n", off, pad)
   414  		off += pad
   415  	}
   416  	if t := n.FuncType.Result; t != nil {
   417  		if off%t.Align != 0 {
   418  			pad := t.Align - off%t.Align
   419  			fmt.Fprintf(&buf, "\t\tchar __pad%d[%d];\n", off, pad)
   420  			off += pad
   421  		}
   422  		fmt.Fprintf(&buf, "\t\t%s r;\n", t.C)
   423  		off += t.Size
   424  	}
   425  	if off%p.PtrSize != 0 {
   426  		pad := p.PtrSize - off%p.PtrSize
   427  		fmt.Fprintf(&buf, "\t\tchar __pad%d[%d];\n", off, pad)
   428  		off += pad
   429  	}
   430  	if off == 0 {
   431  		fmt.Fprintf(&buf, "\t\tchar unused;\n") // avoid empty struct
   432  	}
   433  	fmt.Fprintf(&buf, "\t}")
   434  	return buf.String(), off
   435  }
   436  
   437  func (p *Package) writeDefsFunc(fgo2 io.Writer, n *Name, callsMalloc *bool) {
   438  	name := n.Go
   439  	gtype := n.FuncType.Go
   440  	void := gtype.Results == nil || len(gtype.Results.List) == 0
   441  	if n.AddError {
   442  		// Add "error" to return type list.
   443  		// Type list is known to be 0 or 1 element - it's a C function.
   444  		err := &ast.Field{Type: ast.NewIdent("error")}
   445  		l := gtype.Results.List
   446  		if len(l) == 0 {
   447  			l = []*ast.Field{err}
   448  		} else {
   449  			l = []*ast.Field{l[0], err}
   450  		}
   451  		t := new(ast.FuncType)
   452  		*t = *gtype
   453  		t.Results = &ast.FieldList{List: l}
   454  		gtype = t
   455  	}
   456  
   457  	// Go func declaration.
   458  	d := &ast.FuncDecl{
   459  		Name: ast.NewIdent(n.Mangle),
   460  		Type: gtype,
   461  	}
   462  
   463  	// Builtins defined in the C prolog.
   464  	inProlog := builtinDefs[name] != ""
   465  	cname := fmt.Sprintf("_cgo%s%s", cPrefix, n.Mangle)
   466  	paramnames := []string(nil)
   467  	if d.Type.Params != nil {
   468  		for i, param := range d.Type.Params.List {
   469  			paramName := fmt.Sprintf("p%d", i)
   470  			param.Names = []*ast.Ident{ast.NewIdent(paramName)}
   471  			paramnames = append(paramnames, paramName)
   472  		}
   473  	}
   474  
   475  	if *gccgo {
   476  		// Gccgo style hooks.
   477  		fmt.Fprint(fgo2, "\n")
   478  		conf.Fprint(fgo2, fset, d)
   479  		fmt.Fprint(fgo2, " {\n")
   480  		if !inProlog {
   481  			fmt.Fprint(fgo2, "\tdefer syscall.CgocallDone()\n")
   482  			fmt.Fprint(fgo2, "\tsyscall.Cgocall()\n")
   483  		}
   484  		if n.AddError {
   485  			fmt.Fprint(fgo2, "\tsyscall.SetErrno(0)\n")
   486  		}
   487  		fmt.Fprint(fgo2, "\t")
   488  		if !void {
   489  			fmt.Fprint(fgo2, "r := ")
   490  		}
   491  		fmt.Fprintf(fgo2, "%s(%s)\n", cname, strings.Join(paramnames, ", "))
   492  
   493  		if n.AddError {
   494  			fmt.Fprint(fgo2, "\te := syscall.GetErrno()\n")
   495  			fmt.Fprint(fgo2, "\tif e != 0 {\n")
   496  			fmt.Fprint(fgo2, "\t\treturn ")
   497  			if !void {
   498  				fmt.Fprint(fgo2, "r, ")
   499  			}
   500  			fmt.Fprint(fgo2, "e\n")
   501  			fmt.Fprint(fgo2, "\t}\n")
   502  			fmt.Fprint(fgo2, "\treturn ")
   503  			if !void {
   504  				fmt.Fprint(fgo2, "r, ")
   505  			}
   506  			fmt.Fprint(fgo2, "nil\n")
   507  		} else if !void {
   508  			fmt.Fprint(fgo2, "\treturn r\n")
   509  		}
   510  
   511  		fmt.Fprint(fgo2, "}\n")
   512  
   513  		// declare the C function.
   514  		fmt.Fprintf(fgo2, "//extern %s\n", cname)
   515  		d.Name = ast.NewIdent(cname)
   516  		if n.AddError {
   517  			l := d.Type.Results.List
   518  			d.Type.Results.List = l[:len(l)-1]
   519  		}
   520  		conf.Fprint(fgo2, fset, d)
   521  		fmt.Fprint(fgo2, "\n")
   522  
   523  		return
   524  	}
   525  
   526  	if inProlog {
   527  		fmt.Fprint(fgo2, builtinDefs[name])
   528  		if strings.Contains(builtinDefs[name], "_cgo_cmalloc") {
   529  			*callsMalloc = true
   530  		}
   531  		return
   532  	}
   533  
   534  	// Wrapper calls into gcc, passing a pointer to the argument frame.
   535  	fmt.Fprintf(fgo2, "//go:cgo_import_static %s\n", cname)
   536  	fmt.Fprintf(fgo2, "//go:linkname __cgofn_%s %s\n", cname, cname)
   537  	fmt.Fprintf(fgo2, "var __cgofn_%s byte\n", cname)
   538  	fmt.Fprintf(fgo2, "var %s = unsafe.Pointer(&__cgofn_%s)\n", cname, cname)
   539  
   540  	nret := 0
   541  	if !void {
   542  		d.Type.Results.List[0].Names = []*ast.Ident{ast.NewIdent("r1")}
   543  		nret = 1
   544  	}
   545  	if n.AddError {
   546  		d.Type.Results.List[nret].Names = []*ast.Ident{ast.NewIdent("r2")}
   547  	}
   548  
   549  	fmt.Fprint(fgo2, "\n")
   550  	fmt.Fprint(fgo2, "//go:cgo_unsafe_args\n")
   551  	conf.Fprint(fgo2, fset, d)
   552  	fmt.Fprint(fgo2, " {\n")
   553  
   554  	// NOTE: Using uintptr to hide from escape analysis.
   555  	arg := "0"
   556  	if len(paramnames) > 0 {
   557  		arg = "uintptr(unsafe.Pointer(&p0))"
   558  	} else if !void {
   559  		arg = "uintptr(unsafe.Pointer(&r1))"
   560  	}
   561  
   562  	prefix := ""
   563  	if n.AddError {
   564  		prefix = "errno := "
   565  	}
   566  	fmt.Fprintf(fgo2, "\t%s_cgo_runtime_cgocall(%s, %s)\n", prefix, cname, arg)
   567  	if n.AddError {
   568  		fmt.Fprintf(fgo2, "\tif errno != 0 { r2 = syscall.Errno(errno) }\n")
   569  	}
   570  	fmt.Fprintf(fgo2, "\tif _Cgo_always_false {\n")
   571  	if d.Type.Params != nil {
   572  		for i := range d.Type.Params.List {
   573  			fmt.Fprintf(fgo2, "\t\t_Cgo_use(p%d)\n", i)
   574  		}
   575  	}
   576  	fmt.Fprintf(fgo2, "\t}\n")
   577  	fmt.Fprintf(fgo2, "\treturn\n")
   578  	fmt.Fprintf(fgo2, "}\n")
   579  }
   580  
   581  // writeOutput creates stubs for a specific source file to be compiled by gc
   582  func (p *Package) writeOutput(f *File, srcfile string) {
   583  	base := srcfile
   584  	if strings.HasSuffix(base, ".go") {
   585  		base = base[0 : len(base)-3]
   586  	}
   587  	base = filepath.Base(base)
   588  	fgo1 := creat(*objDir + base + ".cgo1.go")
   589  	fgcc := creat(*objDir + base + ".cgo2.c")
   590  
   591  	p.GoFiles = append(p.GoFiles, base+".cgo1.go")
   592  	p.GccFiles = append(p.GccFiles, base+".cgo2.c")
   593  
   594  	// Write Go output: Go input with rewrites of C.xxx to _C_xxx.
   595  	fmt.Fprintf(fgo1, "// Code generated by cmd/cgo; DO NOT EDIT.\n\n")
   596  	fmt.Fprintf(fgo1, "//line %s:1:1\n", srcfile)
   597  	fgo1.Write(f.Edit.Bytes())
   598  
   599  	// While we process the vars and funcs, also write gcc output.
   600  	// Gcc output starts with the preamble.
   601  	fmt.Fprintf(fgcc, "%s\n", builtinProlog)
   602  	fmt.Fprintf(fgcc, "%s\n", f.Preamble)
   603  	fmt.Fprintf(fgcc, "%s\n", gccProlog)
   604  	fmt.Fprintf(fgcc, "%s\n", tsanProlog)
   605  	fmt.Fprintf(fgcc, "%s\n", msanProlog)
   606  
   607  	for _, key := range nameKeys(f.Name) {
   608  		n := f.Name[key]
   609  		if n.FuncType != nil {
   610  			p.writeOutputFunc(fgcc, n)
   611  		}
   612  	}
   613  
   614  	fgo1.Close()
   615  	fgcc.Close()
   616  }
   617  
   618  // fixGo converts the internal Name.Go field into the name we should show
   619  // to users in error messages. There's only one for now: on input we rewrite
   620  // C.malloc into C._CMalloc, so change it back here.
   621  func fixGo(name string) string {
   622  	if name == "_CMalloc" {
   623  		return "malloc"
   624  	}
   625  	return name
   626  }
   627  
   628  var isBuiltin = map[string]bool{
   629  	"_Cfunc_CString":   true,
   630  	"_Cfunc_CBytes":    true,
   631  	"_Cfunc_GoString":  true,
   632  	"_Cfunc_GoStringN": true,
   633  	"_Cfunc_GoBytes":   true,
   634  	"_Cfunc__CMalloc":  true,
   635  }
   636  
   637  func (p *Package) writeOutputFunc(fgcc *os.File, n *Name) {
   638  	name := n.Mangle
   639  	if isBuiltin[name] || p.Written[name] {
   640  		// The builtins are already defined in the C prolog, and we don't
   641  		// want to duplicate function definitions we've already done.
   642  		return
   643  	}
   644  	p.Written[name] = true
   645  
   646  	if *gccgo {
   647  		p.writeGccgoOutputFunc(fgcc, n)
   648  		return
   649  	}
   650  
   651  	ctype, _ := p.structType(n)
   652  
   653  	// Gcc wrapper unpacks the C argument struct
   654  	// and calls the actual C function.
   655  	fmt.Fprintf(fgcc, "CGO_NO_SANITIZE_THREAD\n")
   656  	if n.AddError {
   657  		fmt.Fprintf(fgcc, "int\n")
   658  	} else {
   659  		fmt.Fprintf(fgcc, "void\n")
   660  	}
   661  	fmt.Fprintf(fgcc, "_cgo%s%s(void *v)\n", cPrefix, n.Mangle)
   662  	fmt.Fprintf(fgcc, "{\n")
   663  	if n.AddError {
   664  		fmt.Fprintf(fgcc, "\tint _cgo_errno;\n")
   665  	}
   666  	// We're trying to write a gcc struct that matches gc's layout.
   667  	// Use packed attribute to force no padding in this struct in case
   668  	// gcc has different packing requirements.
   669  	fmt.Fprintf(fgcc, "\t%s %v *_cgo_a = v;\n", ctype, p.packedAttribute())
   670  	if n.FuncType.Result != nil {
   671  		// Save the stack top for use below.
   672  		fmt.Fprintf(fgcc, "\tchar *_cgo_stktop = _cgo_topofstack();\n")
   673  	}
   674  	tr := n.FuncType.Result
   675  	if tr != nil {
   676  		fmt.Fprintf(fgcc, "\t__typeof__(_cgo_a->r) _cgo_r;\n")
   677  	}
   678  	fmt.Fprintf(fgcc, "\t_cgo_tsan_acquire();\n")
   679  	if n.AddError {
   680  		fmt.Fprintf(fgcc, "\terrno = 0;\n")
   681  	}
   682  	fmt.Fprintf(fgcc, "\t")
   683  	if tr != nil {
   684  		fmt.Fprintf(fgcc, "_cgo_r = ")
   685  		if c := tr.C.String(); c[len(c)-1] == '*' {
   686  			fmt.Fprint(fgcc, "(__typeof__(_cgo_a->r)) ")
   687  		}
   688  	}
   689  	if n.Kind == "macro" {
   690  		fmt.Fprintf(fgcc, "%s;\n", n.C)
   691  	} else {
   692  		fmt.Fprintf(fgcc, "%s(", n.C)
   693  		for i := range n.FuncType.Params {
   694  			if i > 0 {
   695  				fmt.Fprintf(fgcc, ", ")
   696  			}
   697  			fmt.Fprintf(fgcc, "_cgo_a->p%d", i)
   698  		}
   699  		fmt.Fprintf(fgcc, ");\n")
   700  	}
   701  	if n.AddError {
   702  		fmt.Fprintf(fgcc, "\t_cgo_errno = errno;\n")
   703  	}
   704  	fmt.Fprintf(fgcc, "\t_cgo_tsan_release();\n")
   705  	if n.FuncType.Result != nil {
   706  		// The cgo call may have caused a stack copy (via a callback).
   707  		// Adjust the return value pointer appropriately.
   708  		fmt.Fprintf(fgcc, "\t_cgo_a = (void*)((char*)_cgo_a + (_cgo_topofstack() - _cgo_stktop));\n")
   709  		// Save the return value.
   710  		fmt.Fprintf(fgcc, "\t_cgo_a->r = _cgo_r;\n")
   711  		// The return value is on the Go stack. If we are using msan,
   712  		// and if the C value is partially or completely uninitialized,
   713  		// the assignment will mark the Go stack as uninitialized.
   714  		// The Go compiler does not update msan for changes to the
   715  		// stack. It is possible that the stack will remain
   716  		// uninitialized, and then later be used in a way that is
   717  		// visible to msan, possibly leading to a false positive.
   718  		// Mark the stack space as written, to avoid this problem.
   719  		// See issue 26209.
   720  		fmt.Fprintf(fgcc, "\t_cgo_msan_write(&_cgo_a->r, sizeof(_cgo_a->r));\n")
   721  	}
   722  	if n.AddError {
   723  		fmt.Fprintf(fgcc, "\treturn _cgo_errno;\n")
   724  	}
   725  	fmt.Fprintf(fgcc, "}\n")
   726  	fmt.Fprintf(fgcc, "\n")
   727  }
   728  
   729  // Write out a wrapper for a function when using gccgo. This is a
   730  // simple wrapper that just calls the real function. We only need a
   731  // wrapper to support static functions in the prologue--without a
   732  // wrapper, we can't refer to the function, since the reference is in
   733  // a different file.
   734  func (p *Package) writeGccgoOutputFunc(fgcc *os.File, n *Name) {
   735  	fmt.Fprintf(fgcc, "CGO_NO_SANITIZE_THREAD\n")
   736  	if t := n.FuncType.Result; t != nil {
   737  		fmt.Fprintf(fgcc, "%s\n", t.C.String())
   738  	} else {
   739  		fmt.Fprintf(fgcc, "void\n")
   740  	}
   741  	fmt.Fprintf(fgcc, "_cgo%s%s(", cPrefix, n.Mangle)
   742  	for i, t := range n.FuncType.Params {
   743  		if i > 0 {
   744  			fmt.Fprintf(fgcc, ", ")
   745  		}
   746  		c := t.Typedef
   747  		if c == "" {
   748  			c = t.C.String()
   749  		}
   750  		fmt.Fprintf(fgcc, "%s p%d", c, i)
   751  	}
   752  	fmt.Fprintf(fgcc, ")\n")
   753  	fmt.Fprintf(fgcc, "{\n")
   754  	if t := n.FuncType.Result; t != nil {
   755  		fmt.Fprintf(fgcc, "\t%s _cgo_r;\n", t.C.String())
   756  	}
   757  	fmt.Fprintf(fgcc, "\t_cgo_tsan_acquire();\n")
   758  	fmt.Fprintf(fgcc, "\t")
   759  	if t := n.FuncType.Result; t != nil {
   760  		fmt.Fprintf(fgcc, "_cgo_r = ")
   761  		// Cast to void* to avoid warnings due to omitted qualifiers.
   762  		if c := t.C.String(); c[len(c)-1] == '*' {
   763  			fmt.Fprintf(fgcc, "(void*)")
   764  		}
   765  	}
   766  	if n.Kind == "macro" {
   767  		fmt.Fprintf(fgcc, "%s;\n", n.C)
   768  	} else {
   769  		fmt.Fprintf(fgcc, "%s(", n.C)
   770  		for i := range n.FuncType.Params {
   771  			if i > 0 {
   772  				fmt.Fprintf(fgcc, ", ")
   773  			}
   774  			fmt.Fprintf(fgcc, "p%d", i)
   775  		}
   776  		fmt.Fprintf(fgcc, ");\n")
   777  	}
   778  	fmt.Fprintf(fgcc, "\t_cgo_tsan_release();\n")
   779  	if t := n.FuncType.Result; t != nil {
   780  		fmt.Fprintf(fgcc, "\treturn ")
   781  		// Cast to void* to avoid warnings due to omitted qualifiers
   782  		// and explicit incompatible struct types.
   783  		if c := t.C.String(); c[len(c)-1] == '*' {
   784  			fmt.Fprintf(fgcc, "(void*)")
   785  		}
   786  		fmt.Fprintf(fgcc, "_cgo_r;\n")
   787  	}
   788  	fmt.Fprintf(fgcc, "}\n")
   789  	fmt.Fprintf(fgcc, "\n")
   790  }
   791  
   792  // packedAttribute returns host compiler struct attribute that will be
   793  // used to match gc's struct layout. For example, on 386 Windows,
   794  // gcc wants to 8-align int64s, but gc does not.
   795  // Use __gcc_struct__ to work around https://gcc.gnu.org/PR52991 on x86,
   796  // and https://golang.org/issue/5603.
   797  func (p *Package) packedAttribute() string {
   798  	s := "__attribute__((__packed__"
   799  	if !p.GccIsClang && (goarch == "amd64" || goarch == "386") {
   800  		s += ", __gcc_struct__"
   801  	}
   802  	return s + "))"
   803  }
   804  
   805  // Write out the various stubs we need to support functions exported
   806  // from Go so that they are callable from C.
   807  func (p *Package) writeExports(fgo2, fm, fgcc, fgcch io.Writer) {
   808  	p.writeExportHeader(fgcch)
   809  
   810  	fmt.Fprintf(fgcc, "/* Code generated by cmd/cgo; DO NOT EDIT. */\n\n")
   811  	fmt.Fprintf(fgcc, "#include <stdlib.h>\n")
   812  	fmt.Fprintf(fgcc, "#include \"_cgo_export.h\"\n\n")
   813  
   814  	// We use packed structs, but they are always aligned.
   815  	// The pragmas and address-of-packed-member are only recognized as
   816  	// warning groups in clang 4.0+, so ignore unknown pragmas first.
   817  	fmt.Fprintf(fgcc, "#pragma GCC diagnostic ignored \"-Wunknown-pragmas\"\n")
   818  	fmt.Fprintf(fgcc, "#pragma GCC diagnostic ignored \"-Wpragmas\"\n")
   819  	fmt.Fprintf(fgcc, "#pragma GCC diagnostic ignored \"-Waddress-of-packed-member\"\n")
   820  
   821  	fmt.Fprintf(fgcc, "extern void crosscall2(void (*fn)(void *, int, __SIZE_TYPE__), void *, int, __SIZE_TYPE__);\n")
   822  	fmt.Fprintf(fgcc, "extern __SIZE_TYPE__ _cgo_wait_runtime_init_done(void);\n")
   823  	fmt.Fprintf(fgcc, "extern void _cgo_release_context(__SIZE_TYPE__);\n\n")
   824  	fmt.Fprintf(fgcc, "extern char* _cgo_topofstack(void);")
   825  	fmt.Fprintf(fgcc, "%s\n", tsanProlog)
   826  	fmt.Fprintf(fgcc, "%s\n", msanProlog)
   827  
   828  	for _, exp := range p.ExpFunc {
   829  		fn := exp.Func
   830  
   831  		// Construct a gcc struct matching the gc argument and
   832  		// result frame. The gcc struct will be compiled with
   833  		// __attribute__((packed)) so all padding must be accounted
   834  		// for explicitly.
   835  		ctype := "struct {\n"
   836  		off := int64(0)
   837  		npad := 0
   838  		if fn.Recv != nil {
   839  			t := p.cgoType(fn.Recv.List[0].Type)
   840  			ctype += fmt.Sprintf("\t\t%s recv;\n", t.C)
   841  			off += t.Size
   842  		}
   843  		fntype := fn.Type
   844  		forFieldList(fntype.Params,
   845  			func(i int, aname string, atype ast.Expr) {
   846  				t := p.cgoType(atype)
   847  				if off%t.Align != 0 {
   848  					pad := t.Align - off%t.Align
   849  					ctype += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad)
   850  					off += pad
   851  					npad++
   852  				}
   853  				ctype += fmt.Sprintf("\t\t%s p%d;\n", t.C, i)
   854  				off += t.Size
   855  			})
   856  		if off%p.PtrSize != 0 {
   857  			pad := p.PtrSize - off%p.PtrSize
   858  			ctype += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad)
   859  			off += pad
   860  			npad++
   861  		}
   862  		forFieldList(fntype.Results,
   863  			func(i int, aname string, atype ast.Expr) {
   864  				t := p.cgoType(atype)
   865  				if off%t.Align != 0 {
   866  					pad := t.Align - off%t.Align
   867  					ctype += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad)
   868  					off += pad
   869  					npad++
   870  				}
   871  				ctype += fmt.Sprintf("\t\t%s r%d;\n", t.C, i)
   872  				off += t.Size
   873  			})
   874  		if off%p.PtrSize != 0 {
   875  			pad := p.PtrSize - off%p.PtrSize
   876  			ctype += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad)
   877  			off += pad
   878  			npad++
   879  		}
   880  		if ctype == "struct {\n" {
   881  			ctype += "\t\tchar unused;\n" // avoid empty struct
   882  		}
   883  		ctype += "\t}"
   884  
   885  		// Get the return type of the wrapper function
   886  		// compiled by gcc.
   887  		gccResult := ""
   888  		if fntype.Results == nil || len(fntype.Results.List) == 0 {
   889  			gccResult = "void"
   890  		} else if len(fntype.Results.List) == 1 && len(fntype.Results.List[0].Names) <= 1 {
   891  			gccResult = p.cgoType(fntype.Results.List[0].Type).C.String()
   892  		} else {
   893  			fmt.Fprintf(fgcch, "\n/* Return type for %s */\n", exp.ExpName)
   894  			fmt.Fprintf(fgcch, "struct %s_return {\n", exp.ExpName)
   895  			forFieldList(fntype.Results,
   896  				func(i int, aname string, atype ast.Expr) {
   897  					fmt.Fprintf(fgcch, "\t%s r%d;", p.cgoType(atype).C, i)
   898  					if len(aname) > 0 {
   899  						fmt.Fprintf(fgcch, " /* %s */", aname)
   900  					}
   901  					fmt.Fprint(fgcch, "\n")
   902  				})
   903  			fmt.Fprintf(fgcch, "};\n")
   904  			gccResult = "struct " + exp.ExpName + "_return"
   905  		}
   906  
   907  		// Build the wrapper function compiled by gcc.
   908  		s := fmt.Sprintf("%s %s(", gccResult, exp.ExpName)
   909  		if fn.Recv != nil {
   910  			s += p.cgoType(fn.Recv.List[0].Type).C.String()
   911  			s += " recv"
   912  		}
   913  		forFieldList(fntype.Params,
   914  			func(i int, aname string, atype ast.Expr) {
   915  				if i > 0 || fn.Recv != nil {
   916  					s += ", "
   917  				}
   918  				s += fmt.Sprintf("%s p%d", p.cgoType(atype).C, i)
   919  			})
   920  		s += ")"
   921  
   922  		if len(exp.Doc) > 0 {
   923  			fmt.Fprintf(fgcch, "\n%s", exp.Doc)
   924  		}
   925  		fmt.Fprintf(fgcch, "\nextern %s;\n", s)
   926  
   927  		fmt.Fprintf(fgcc, "extern void _cgoexp%s_%s(void *, int, __SIZE_TYPE__);\n", cPrefix, exp.ExpName)
   928  		fmt.Fprintf(fgcc, "\nCGO_NO_SANITIZE_THREAD")
   929  		fmt.Fprintf(fgcc, "\n%s\n", s)
   930  		fmt.Fprintf(fgcc, "{\n")
   931  		fmt.Fprintf(fgcc, "\t__SIZE_TYPE__ _cgo_ctxt = _cgo_wait_runtime_init_done();\n")
   932  		fmt.Fprintf(fgcc, "\t%s %v a;\n", ctype, p.packedAttribute())
   933  		if gccResult != "void" && (len(fntype.Results.List) > 1 || len(fntype.Results.List[0].Names) > 1) {
   934  			fmt.Fprintf(fgcc, "\t%s r;\n", gccResult)
   935  		}
   936  		if fn.Recv != nil {
   937  			fmt.Fprintf(fgcc, "\ta.recv = recv;\n")
   938  		}
   939  		forFieldList(fntype.Params,
   940  			func(i int, aname string, atype ast.Expr) {
   941  				fmt.Fprintf(fgcc, "\ta.p%d = p%d;\n", i, i)
   942  			})
   943  		fmt.Fprintf(fgcc, "\t_cgo_tsan_release();\n")
   944  		fmt.Fprintf(fgcc, "\tcrosscall2(_cgoexp%s_%s, &a, %d, _cgo_ctxt);\n", cPrefix, exp.ExpName, off)
   945  		fmt.Fprintf(fgcc, "\t_cgo_tsan_acquire();\n")
   946  		fmt.Fprintf(fgcc, "\t_cgo_release_context(_cgo_ctxt);\n")
   947  		if gccResult != "void" {
   948  			if len(fntype.Results.List) == 1 && len(fntype.Results.List[0].Names) <= 1 {
   949  				fmt.Fprintf(fgcc, "\treturn a.r0;\n")
   950  			} else {
   951  				forFieldList(fntype.Results,
   952  					func(i int, aname string, atype ast.Expr) {
   953  						fmt.Fprintf(fgcc, "\tr.r%d = a.r%d;\n", i, i)
   954  					})
   955  				fmt.Fprintf(fgcc, "\treturn r;\n")
   956  			}
   957  		}
   958  		fmt.Fprintf(fgcc, "}\n")
   959  
   960  		// Build the wrapper function compiled by cmd/compile.
   961  		goname := "_cgoexpwrap" + cPrefix + "_"
   962  		if fn.Recv != nil {
   963  			goname += fn.Recv.List[0].Names[0].Name + "_"
   964  		}
   965  		goname += exp.Func.Name.Name
   966  		fmt.Fprintf(fgo2, "//go:cgo_export_dynamic %s\n", exp.ExpName)
   967  		fmt.Fprintf(fgo2, "//go:linkname _cgoexp%s_%s _cgoexp%s_%s\n", cPrefix, exp.ExpName, cPrefix, exp.ExpName)
   968  		fmt.Fprintf(fgo2, "//go:cgo_export_static _cgoexp%s_%s\n", cPrefix, exp.ExpName)
   969  		fmt.Fprintf(fgo2, "//go:nosplit\n") // no split stack, so no use of m or g
   970  		fmt.Fprintf(fgo2, "//go:norace\n")  // must not have race detector calls inserted
   971  		fmt.Fprintf(fgo2, "func _cgoexp%s_%s(a unsafe.Pointer, n int32, ctxt uintptr) {\n", cPrefix, exp.ExpName)
   972  		fmt.Fprintf(fgo2, "\tfn := %s\n", goname)
   973  		// The indirect here is converting from a Go function pointer to a C function pointer.
   974  		fmt.Fprintf(fgo2, "\t_cgo_runtime_cgocallback(**(**unsafe.Pointer)(unsafe.Pointer(&fn)), a, uintptr(n), ctxt);\n")
   975  		fmt.Fprintf(fgo2, "}\n")
   976  
   977  		fmt.Fprintf(fm, "int _cgoexp%s_%s;\n", cPrefix, exp.ExpName)
   978  
   979  		// This code uses printer.Fprint, not conf.Fprint,
   980  		// because we don't want //line comments in the middle
   981  		// of the function types.
   982  		fmt.Fprintf(fgo2, "\n")
   983  		fmt.Fprintf(fgo2, "func %s(", goname)
   984  		comma := false
   985  		if fn.Recv != nil {
   986  			fmt.Fprintf(fgo2, "recv ")
   987  			printer.Fprint(fgo2, fset, fn.Recv.List[0].Type)
   988  			comma = true
   989  		}
   990  		forFieldList(fntype.Params,
   991  			func(i int, aname string, atype ast.Expr) {
   992  				if comma {
   993  					fmt.Fprintf(fgo2, ", ")
   994  				}
   995  				fmt.Fprintf(fgo2, "p%d ", i)
   996  				printer.Fprint(fgo2, fset, atype)
   997  				comma = true
   998  			})
   999  		fmt.Fprintf(fgo2, ")")
  1000  		if gccResult != "void" {
  1001  			fmt.Fprint(fgo2, " (")
  1002  			forFieldList(fntype.Results,
  1003  				func(i int, aname string, atype ast.Expr) {
  1004  					if i > 0 {
  1005  						fmt.Fprint(fgo2, ", ")
  1006  					}
  1007  					fmt.Fprintf(fgo2, "r%d ", i)
  1008  					printer.Fprint(fgo2, fset, atype)
  1009  				})
  1010  			fmt.Fprint(fgo2, ")")
  1011  		}
  1012  		fmt.Fprint(fgo2, " {\n")
  1013  		if gccResult == "void" {
  1014  			fmt.Fprint(fgo2, "\t")
  1015  		} else {
  1016  			// Verify that any results don't contain any
  1017  			// Go pointers.
  1018  			addedDefer := false
  1019  			forFieldList(fntype.Results,
  1020  				func(i int, aname string, atype ast.Expr) {
  1021  					if !p.hasPointer(nil, atype, false) {
  1022  						return
  1023  					}
  1024  					if !addedDefer {
  1025  						fmt.Fprint(fgo2, "\tdefer func() {\n")
  1026  						addedDefer = true
  1027  					}
  1028  					fmt.Fprintf(fgo2, "\t\t_cgoCheckResult(r%d)\n", i)
  1029  				})
  1030  			if addedDefer {
  1031  				fmt.Fprint(fgo2, "\t}()\n")
  1032  			}
  1033  			fmt.Fprint(fgo2, "\treturn ")
  1034  		}
  1035  		if fn.Recv != nil {
  1036  			fmt.Fprintf(fgo2, "recv.")
  1037  		}
  1038  		fmt.Fprintf(fgo2, "%s(", exp.Func.Name)
  1039  		forFieldList(fntype.Params,
  1040  			func(i int, aname string, atype ast.Expr) {
  1041  				if i > 0 {
  1042  					fmt.Fprint(fgo2, ", ")
  1043  				}
  1044  				fmt.Fprintf(fgo2, "p%d", i)
  1045  			})
  1046  		fmt.Fprint(fgo2, ")\n")
  1047  		fmt.Fprint(fgo2, "}\n")
  1048  	}
  1049  
  1050  	fmt.Fprintf(fgcch, "%s", gccExportHeaderEpilog)
  1051  }
  1052  
  1053  // Write out the C header allowing C code to call exported gccgo functions.
  1054  func (p *Package) writeGccgoExports(fgo2, fm, fgcc, fgcch io.Writer) {
  1055  	gccgoSymbolPrefix := p.gccgoSymbolPrefix()
  1056  
  1057  	p.writeExportHeader(fgcch)
  1058  
  1059  	fmt.Fprintf(fgcc, "/* Code generated by cmd/cgo; DO NOT EDIT. */\n\n")
  1060  	fmt.Fprintf(fgcc, "#include \"_cgo_export.h\"\n")
  1061  
  1062  	fmt.Fprintf(fgcc, "%s\n", gccgoExportFileProlog)
  1063  	fmt.Fprintf(fgcc, "%s\n", tsanProlog)
  1064  	fmt.Fprintf(fgcc, "%s\n", msanProlog)
  1065  
  1066  	for _, exp := range p.ExpFunc {
  1067  		fn := exp.Func
  1068  		fntype := fn.Type
  1069  
  1070  		cdeclBuf := new(bytes.Buffer)
  1071  		resultCount := 0
  1072  		forFieldList(fntype.Results,
  1073  			func(i int, aname string, atype ast.Expr) { resultCount++ })
  1074  		switch resultCount {
  1075  		case 0:
  1076  			fmt.Fprintf(cdeclBuf, "void")
  1077  		case 1:
  1078  			forFieldList(fntype.Results,
  1079  				func(i int, aname string, atype ast.Expr) {
  1080  					t := p.cgoType(atype)
  1081  					fmt.Fprintf(cdeclBuf, "%s", t.C)
  1082  				})
  1083  		default:
  1084  			// Declare a result struct.
  1085  			fmt.Fprintf(fgcch, "\n/* Return type for %s */\n", exp.ExpName)
  1086  			fmt.Fprintf(fgcch, "struct %s_return {\n", exp.ExpName)
  1087  			forFieldList(fntype.Results,
  1088  				func(i int, aname string, atype ast.Expr) {
  1089  					t := p.cgoType(atype)
  1090  					fmt.Fprintf(fgcch, "\t%s r%d;", t.C, i)
  1091  					if len(aname) > 0 {
  1092  						fmt.Fprintf(fgcch, " /* %s */", aname)
  1093  					}
  1094  					fmt.Fprint(fgcch, "\n")
  1095  				})
  1096  			fmt.Fprintf(fgcch, "};\n")
  1097  			fmt.Fprintf(cdeclBuf, "struct %s_return", exp.ExpName)
  1098  		}
  1099  
  1100  		cRet := cdeclBuf.String()
  1101  
  1102  		cdeclBuf = new(bytes.Buffer)
  1103  		fmt.Fprintf(cdeclBuf, "(")
  1104  		if fn.Recv != nil {
  1105  			fmt.Fprintf(cdeclBuf, "%s recv", p.cgoType(fn.Recv.List[0].Type).C.String())
  1106  		}
  1107  		// Function parameters.
  1108  		forFieldList(fntype.Params,
  1109  			func(i int, aname string, atype ast.Expr) {
  1110  				if i > 0 || fn.Recv != nil {
  1111  					fmt.Fprintf(cdeclBuf, ", ")
  1112  				}
  1113  				t := p.cgoType(atype)
  1114  				fmt.Fprintf(cdeclBuf, "%s p%d", t.C, i)
  1115  			})
  1116  		fmt.Fprintf(cdeclBuf, ")")
  1117  		cParams := cdeclBuf.String()
  1118  
  1119  		if len(exp.Doc) > 0 {
  1120  			fmt.Fprintf(fgcch, "\n%s", exp.Doc)
  1121  		}
  1122  
  1123  		fmt.Fprintf(fgcch, "extern %s %s%s;\n", cRet, exp.ExpName, cParams)
  1124  
  1125  		// We need to use a name that will be exported by the
  1126  		// Go code; otherwise gccgo will make it static and we
  1127  		// will not be able to link against it from the C
  1128  		// code.
  1129  		goName := "Cgoexp_" + exp.ExpName
  1130  		fmt.Fprintf(fgcc, `extern %s %s %s __asm__("%s.%s");`, cRet, goName, cParams, gccgoSymbolPrefix, goName)
  1131  		fmt.Fprint(fgcc, "\n")
  1132  
  1133  		fmt.Fprint(fgcc, "\nCGO_NO_SANITIZE_THREAD\n")
  1134  		fmt.Fprintf(fgcc, "%s %s %s {\n", cRet, exp.ExpName, cParams)
  1135  		if resultCount > 0 {
  1136  			fmt.Fprintf(fgcc, "\t%s r;\n", cRet)
  1137  		}
  1138  		fmt.Fprintf(fgcc, "\tif(_cgo_wait_runtime_init_done)\n")
  1139  		fmt.Fprintf(fgcc, "\t\t_cgo_wait_runtime_init_done();\n")
  1140  		fmt.Fprintf(fgcc, "\t_cgo_tsan_release();\n")
  1141  		fmt.Fprint(fgcc, "\t")
  1142  		if resultCount > 0 {
  1143  			fmt.Fprint(fgcc, "r = ")
  1144  		}
  1145  		fmt.Fprintf(fgcc, "%s(", goName)
  1146  		if fn.Recv != nil {
  1147  			fmt.Fprint(fgcc, "recv")
  1148  		}
  1149  		forFieldList(fntype.Params,
  1150  			func(i int, aname string, atype ast.Expr) {
  1151  				if i > 0 || fn.Recv != nil {
  1152  					fmt.Fprintf(fgcc, ", ")
  1153  				}
  1154  				fmt.Fprintf(fgcc, "p%d", i)
  1155  			})
  1156  		fmt.Fprint(fgcc, ");\n")
  1157  		fmt.Fprintf(fgcc, "\t_cgo_tsan_acquire();\n")
  1158  		if resultCount > 0 {
  1159  			fmt.Fprint(fgcc, "\treturn r;\n")
  1160  		}
  1161  		fmt.Fprint(fgcc, "}\n")
  1162  
  1163  		// Dummy declaration for _cgo_main.c
  1164  		fmt.Fprintf(fm, `char %s[1] __asm__("%s.%s");`, goName, gccgoSymbolPrefix, goName)
  1165  		fmt.Fprint(fm, "\n")
  1166  
  1167  		// For gccgo we use a wrapper function in Go, in order
  1168  		// to call CgocallBack and CgocallBackDone.
  1169  
  1170  		// This code uses printer.Fprint, not conf.Fprint,
  1171  		// because we don't want //line comments in the middle
  1172  		// of the function types.
  1173  		fmt.Fprint(fgo2, "\n")
  1174  		fmt.Fprintf(fgo2, "func %s(", goName)
  1175  		if fn.Recv != nil {
  1176  			fmt.Fprint(fgo2, "recv ")
  1177  			printer.Fprint(fgo2, fset, fn.Recv.List[0].Type)
  1178  		}
  1179  		forFieldList(fntype.Params,
  1180  			func(i int, aname string, atype ast.Expr) {
  1181  				if i > 0 || fn.Recv != nil {
  1182  					fmt.Fprintf(fgo2, ", ")
  1183  				}
  1184  				fmt.Fprintf(fgo2, "p%d ", i)
  1185  				printer.Fprint(fgo2, fset, atype)
  1186  			})
  1187  		fmt.Fprintf(fgo2, ")")
  1188  		if resultCount > 0 {
  1189  			fmt.Fprintf(fgo2, " (")
  1190  			forFieldList(fntype.Results,
  1191  				func(i int, aname string, atype ast.Expr) {
  1192  					if i > 0 {
  1193  						fmt.Fprint(fgo2, ", ")
  1194  					}
  1195  					printer.Fprint(fgo2, fset, atype)
  1196  				})
  1197  			fmt.Fprint(fgo2, ")")
  1198  		}
  1199  		fmt.Fprint(fgo2, " {\n")
  1200  		fmt.Fprint(fgo2, "\tsyscall.CgocallBack()\n")
  1201  		fmt.Fprint(fgo2, "\tdefer syscall.CgocallBackDone()\n")
  1202  		fmt.Fprint(fgo2, "\t")
  1203  		if resultCount > 0 {
  1204  			fmt.Fprint(fgo2, "return ")
  1205  		}
  1206  		if fn.Recv != nil {
  1207  			fmt.Fprint(fgo2, "recv.")
  1208  		}
  1209  		fmt.Fprintf(fgo2, "%s(", exp.Func.Name)
  1210  		forFieldList(fntype.Params,
  1211  			func(i int, aname string, atype ast.Expr) {
  1212  				if i > 0 {
  1213  					fmt.Fprint(fgo2, ", ")
  1214  				}
  1215  				fmt.Fprintf(fgo2, "p%d", i)
  1216  			})
  1217  		fmt.Fprint(fgo2, ")\n")
  1218  		fmt.Fprint(fgo2, "}\n")
  1219  	}
  1220  
  1221  	fmt.Fprintf(fgcch, "%s", gccExportHeaderEpilog)
  1222  }
  1223  
  1224  // writeExportHeader writes out the start of the _cgo_export.h file.
  1225  func (p *Package) writeExportHeader(fgcch io.Writer) {
  1226  	fmt.Fprintf(fgcch, "/* Code generated by cmd/cgo; DO NOT EDIT. */\n\n")
  1227  	pkg := *importPath
  1228  	if pkg == "" {
  1229  		pkg = p.PackagePath
  1230  	}
  1231  	fmt.Fprintf(fgcch, "/* package %s */\n\n", pkg)
  1232  	fmt.Fprintf(fgcch, "%s\n", builtinExportProlog)
  1233  
  1234  	// Remove absolute paths from #line comments in the preamble.
  1235  	// They aren't useful for people using the header file,
  1236  	// and they mean that the header files change based on the
  1237  	// exact location of GOPATH.
  1238  	re := regexp.MustCompile(`(?m)^(#line\s+[0-9]+\s+")[^"]*[/\\]([^"]*")`)
  1239  	preamble := re.ReplaceAllString(p.Preamble, "$1$2")
  1240  
  1241  	fmt.Fprintf(fgcch, "/* Start of preamble from import \"C\" comments.  */\n\n")
  1242  	fmt.Fprintf(fgcch, "%s\n", preamble)
  1243  	fmt.Fprintf(fgcch, "\n/* End of preamble from import \"C\" comments.  */\n\n")
  1244  
  1245  	fmt.Fprintf(fgcch, "%s\n", p.gccExportHeaderProlog())
  1246  }
  1247  
  1248  // gccgoUsesNewMangling reports whether gccgo uses the new collision-free
  1249  // packagepath mangling scheme (see determineGccgoManglingScheme for more
  1250  // info).
  1251  func gccgoUsesNewMangling() bool {
  1252  	if !gccgoMangleCheckDone {
  1253  		gccgoNewmanglingInEffect = determineGccgoManglingScheme()
  1254  		gccgoMangleCheckDone = true
  1255  	}
  1256  	return gccgoNewmanglingInEffect
  1257  }
  1258  
  1259  const mangleCheckCode = `
  1260  package läufer
  1261  func Run(x int) int {
  1262    return 1
  1263  }
  1264  `
  1265  
  1266  // determineGccgoManglingScheme performs a runtime test to see which
  1267  // flavor of packagepath mangling gccgo is using. Older versions of
  1268  // gccgo use a simple mangling scheme where there can be collisions
  1269  // between packages whose paths are different but mangle to the same
  1270  // string. More recent versions of gccgo use a new mangler that avoids
  1271  // these collisions. Return value is whether gccgo uses the new mangling.
  1272  func determineGccgoManglingScheme() bool {
  1273  
  1274  	// Emit a small Go file for gccgo to compile.
  1275  	filepat := "*_gccgo_manglecheck.go"
  1276  	var f *os.File
  1277  	var err error
  1278  	if f, err = ioutil.TempFile(*objDir, filepat); err != nil {
  1279  		fatalf("%v", err)
  1280  	}
  1281  	gofilename := f.Name()
  1282  	defer os.Remove(gofilename)
  1283  
  1284  	if err = ioutil.WriteFile(gofilename, []byte(mangleCheckCode), 0666); err != nil {
  1285  		fatalf("%v", err)
  1286  	}
  1287  
  1288  	// Compile with gccgo, capturing generated assembly.
  1289  	gccgocmd := os.Getenv("GCCGO")
  1290  	if gccgocmd == "" {
  1291  		gpath, gerr := exec.LookPath("gccgo")
  1292  		if gerr != nil {
  1293  			fatalf("unable to locate gccgo: %v", gerr)
  1294  		}
  1295  		gccgocmd = gpath
  1296  	}
  1297  	cmd := exec.Command(gccgocmd, "-S", "-o", "-", gofilename)
  1298  	buf, cerr := cmd.CombinedOutput()
  1299  	if cerr != nil {
  1300  		fatalf("%s", cerr)
  1301  	}
  1302  
  1303  	// New mangling: expect go.l..u00e4ufer.Run
  1304  	// Old mangling: expect go.l__ufer.Run
  1305  	return regexp.MustCompile(`go\.l\.\.u00e4ufer\.Run`).Match(buf)
  1306  }
  1307  
  1308  // gccgoPkgpathToSymbolNew converts a package path to a gccgo-style
  1309  // package symbol.
  1310  func gccgoPkgpathToSymbolNew(ppath string) string {
  1311  	bsl := []byte{}
  1312  	changed := false
  1313  	for _, c := range []byte(ppath) {
  1314  		switch {
  1315  		case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z',
  1316  			'0' <= c && c <= '9', c == '_', c == '.':
  1317  			bsl = append(bsl, c)
  1318  		default:
  1319  			changed = true
  1320  			encbytes := []byte(fmt.Sprintf("..z%02x", c))
  1321  			bsl = append(bsl, encbytes...)
  1322  		}
  1323  	}
  1324  	if !changed {
  1325  		return ppath
  1326  	}
  1327  	return string(bsl)
  1328  }
  1329  
  1330  // gccgoPkgpathToSymbolOld converts a package path to a gccgo-style
  1331  // package symbol using the older mangling scheme.
  1332  func gccgoPkgpathToSymbolOld(ppath string) string {
  1333  	clean := func(r rune) rune {
  1334  		switch {
  1335  		case 'A' <= r && r <= 'Z', 'a' <= r && r <= 'z',
  1336  			'0' <= r && r <= '9':
  1337  			return r
  1338  		}
  1339  		return '_'
  1340  	}
  1341  	return strings.Map(clean, ppath)
  1342  }
  1343  
  1344  // gccgoPkgpathToSymbol converts a package path to a mangled packagepath
  1345  // symbol.
  1346  func gccgoPkgpathToSymbol(ppath string) string {
  1347  	if gccgoUsesNewMangling() {
  1348  		return gccgoPkgpathToSymbolNew(ppath)
  1349  	} else {
  1350  		return gccgoPkgpathToSymbolOld(ppath)
  1351  	}
  1352  }
  1353  
  1354  // Return the package prefix when using gccgo.
  1355  func (p *Package) gccgoSymbolPrefix() string {
  1356  	if !*gccgo {
  1357  		return ""
  1358  	}
  1359  
  1360  	if *gccgopkgpath != "" {
  1361  		return gccgoPkgpathToSymbol(*gccgopkgpath)
  1362  	}
  1363  	if *gccgoprefix == "" && p.PackageName == "main" {
  1364  		return "main"
  1365  	}
  1366  	prefix := gccgoPkgpathToSymbol(*gccgoprefix)
  1367  	if prefix == "" {
  1368  		prefix = "go"
  1369  	}
  1370  	return prefix + "." + p.PackageName
  1371  }
  1372  
  1373  // Call a function for each entry in an ast.FieldList, passing the
  1374  // index into the list, the name if any, and the type.
  1375  func forFieldList(fl *ast.FieldList, fn func(int, string, ast.Expr)) {
  1376  	if fl == nil {
  1377  		return
  1378  	}
  1379  	i := 0
  1380  	for _, r := range fl.List {
  1381  		if r.Names == nil {
  1382  			fn(i, "", r.Type)
  1383  			i++
  1384  		} else {
  1385  			for _, n := range r.Names {
  1386  				fn(i, n.Name, r.Type)
  1387  				i++
  1388  			}
  1389  		}
  1390  	}
  1391  }
  1392  
  1393  func c(repr string, args ...interface{}) *TypeRepr {
  1394  	return &TypeRepr{repr, args}
  1395  }
  1396  
  1397  // Map predeclared Go types to Type.
  1398  var goTypes = map[string]*Type{
  1399  	"bool":       {Size: 1, Align: 1, C: c("GoUint8")},
  1400  	"byte":       {Size: 1, Align: 1, C: c("GoUint8")},
  1401  	"int":        {Size: 0, Align: 0, C: c("GoInt")},
  1402  	"uint":       {Size: 0, Align: 0, C: c("GoUint")},
  1403  	"rune":       {Size: 4, Align: 4, C: c("GoInt32")},
  1404  	"int8":       {Size: 1, Align: 1, C: c("GoInt8")},
  1405  	"uint8":      {Size: 1, Align: 1, C: c("GoUint8")},
  1406  	"int16":      {Size: 2, Align: 2, C: c("GoInt16")},
  1407  	"uint16":     {Size: 2, Align: 2, C: c("GoUint16")},
  1408  	"int32":      {Size: 4, Align: 4, C: c("GoInt32")},
  1409  	"uint32":     {Size: 4, Align: 4, C: c("GoUint32")},
  1410  	"int64":      {Size: 8, Align: 8, C: c("GoInt64")},
  1411  	"uint64":     {Size: 8, Align: 8, C: c("GoUint64")},
  1412  	"float32":    {Size: 4, Align: 4, C: c("GoFloat32")},
  1413  	"float64":    {Size: 8, Align: 8, C: c("GoFloat64")},
  1414  	"complex64":  {Size: 8, Align: 4, C: c("GoComplex64")},
  1415  	"complex128": {Size: 16, Align: 8, C: c("GoComplex128")},
  1416  }
  1417  
  1418  // Map an ast type to a Type.
  1419  func (p *Package) cgoType(e ast.Expr) *Type {
  1420  	switch t := e.(type) {
  1421  	case *ast.StarExpr:
  1422  		x := p.cgoType(t.X)
  1423  		return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("%s*", x.C)}
  1424  	case *ast.ArrayType:
  1425  		if t.Len == nil {
  1426  			// Slice: pointer, len, cap.
  1427  			return &Type{Size: p.PtrSize * 3, Align: p.PtrSize, C: c("GoSlice")}
  1428  		}
  1429  		// Non-slice array types are not supported.
  1430  	case *ast.StructType:
  1431  		// Not supported.
  1432  	case *ast.FuncType:
  1433  		return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("void*")}
  1434  	case *ast.InterfaceType:
  1435  		return &Type{Size: 2 * p.PtrSize, Align: p.PtrSize, C: c("GoInterface")}
  1436  	case *ast.MapType:
  1437  		return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("GoMap")}
  1438  	case *ast.ChanType:
  1439  		return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("GoChan")}
  1440  	case *ast.Ident:
  1441  		// Look up the type in the top level declarations.
  1442  		// TODO: Handle types defined within a function.
  1443  		for _, d := range p.Decl {
  1444  			gd, ok := d.(*ast.GenDecl)
  1445  			if !ok || gd.Tok != token.TYPE {
  1446  				continue
  1447  			}
  1448  			for _, spec := range gd.Specs {
  1449  				ts, ok := spec.(*ast.TypeSpec)
  1450  				if !ok {
  1451  					continue
  1452  				}
  1453  				if ts.Name.Name == t.Name {
  1454  					return p.cgoType(ts.Type)
  1455  				}
  1456  			}
  1457  		}
  1458  		if def := typedef[t.Name]; def != nil {
  1459  			return def
  1460  		}
  1461  		if t.Name == "uintptr" {
  1462  			return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("GoUintptr")}
  1463  		}
  1464  		if t.Name == "string" {
  1465  			// The string data is 1 pointer + 1 (pointer-sized) int.
  1466  			return &Type{Size: 2 * p.PtrSize, Align: p.PtrSize, C: c("GoString")}
  1467  		}
  1468  		if t.Name == "error" {
  1469  			return &Type{Size: 2 * p.PtrSize, Align: p.PtrSize, C: c("GoInterface")}
  1470  		}
  1471  		if r, ok := goTypes[t.Name]; ok {
  1472  			if r.Size == 0 { // int or uint
  1473  				rr := new(Type)
  1474  				*rr = *r
  1475  				rr.Size = p.IntSize
  1476  				rr.Align = p.IntSize
  1477  				r = rr
  1478  			}
  1479  			if r.Align > p.PtrSize {
  1480  				r.Align = p.PtrSize
  1481  			}
  1482  			return r
  1483  		}
  1484  		error_(e.Pos(), "unrecognized Go type %s", t.Name)
  1485  		return &Type{Size: 4, Align: 4, C: c("int")}
  1486  	case *ast.SelectorExpr:
  1487  		id, ok := t.X.(*ast.Ident)
  1488  		if ok && id.Name == "unsafe" && t.Sel.Name == "Pointer" {
  1489  			return &Type{Size: p.PtrSize, Align: p.PtrSize, C: c("void*")}
  1490  		}
  1491  	}
  1492  	error_(e.Pos(), "Go type not supported in export: %s", gofmt(e))
  1493  	return &Type{Size: 4, Align: 4, C: c("int")}
  1494  }
  1495  
  1496  const gccProlog = `
  1497  #line 1 "cgo-gcc-prolog"
  1498  /*
  1499    If x and y are not equal, the type will be invalid
  1500    (have a negative array count) and an inscrutable error will come
  1501    out of the compiler and hopefully mention "name".
  1502  */
  1503  #define __cgo_compile_assert_eq(x, y, name) typedef char name[(x-y)*(x-y)*-2+1];
  1504  
  1505  /* Check at compile time that the sizes we use match our expectations. */
  1506  #define __cgo_size_assert(t, n) __cgo_compile_assert_eq(sizeof(t), n, _cgo_sizeof_##t##_is_not_##n)
  1507  
  1508  __cgo_size_assert(char, 1)
  1509  __cgo_size_assert(short, 2)
  1510  __cgo_size_assert(int, 4)
  1511  typedef long long __cgo_long_long;
  1512  __cgo_size_assert(__cgo_long_long, 8)
  1513  __cgo_size_assert(float, 4)
  1514  __cgo_size_assert(double, 8)
  1515  
  1516  extern char* _cgo_topofstack(void);
  1517  
  1518  /*
  1519    We use packed structs, but they are always aligned.
  1520    The pragmas and address-of-packed-member are only recognized as warning
  1521    groups in clang 4.0+, so ignore unknown pragmas first.
  1522  */
  1523  #pragma GCC diagnostic ignored "-Wunknown-pragmas"
  1524  #pragma GCC diagnostic ignored "-Wpragmas"
  1525  #pragma GCC diagnostic ignored "-Waddress-of-packed-member"
  1526  
  1527  #include <errno.h>
  1528  #include <string.h>
  1529  `
  1530  
  1531  // Prologue defining TSAN functions in C.
  1532  const noTsanProlog = `
  1533  #define CGO_NO_SANITIZE_THREAD
  1534  #define _cgo_tsan_acquire()
  1535  #define _cgo_tsan_release()
  1536  `
  1537  
  1538  // This must match the TSAN code in runtime/cgo/libcgo.h.
  1539  // This is used when the code is built with the C/C++ Thread SANitizer,
  1540  // which is not the same as the Go race detector.
  1541  // __tsan_acquire tells TSAN that we are acquiring a lock on a variable,
  1542  // in this case _cgo_sync. __tsan_release releases the lock.
  1543  // (There is no actual lock, we are just telling TSAN that there is.)
  1544  //
  1545  // When we call from Go to C we call _cgo_tsan_acquire.
  1546  // When the C function returns we call _cgo_tsan_release.
  1547  // Similarly, when C calls back into Go we call _cgo_tsan_release
  1548  // and then call _cgo_tsan_acquire when we return to C.
  1549  // These calls tell TSAN that there is a serialization point at the C call.
  1550  //
  1551  // This is necessary because TSAN, which is a C/C++ tool, can not see
  1552  // the synchronization in the Go code. Without these calls, when
  1553  // multiple goroutines call into C code, TSAN does not understand
  1554  // that the calls are properly synchronized on the Go side.
  1555  //
  1556  // To be clear, if the calls are not properly synchronized on the Go side,
  1557  // we will be hiding races. But when using TSAN on mixed Go C/C++ code
  1558  // it is more important to avoid false positives, which reduce confidence
  1559  // in the tool, than to avoid false negatives.
  1560  const yesTsanProlog = `
  1561  #line 1 "cgo-tsan-prolog"
  1562  #define CGO_NO_SANITIZE_THREAD __attribute__ ((no_sanitize_thread))
  1563  
  1564  long long _cgo_sync __attribute__ ((common));
  1565  
  1566  extern void __tsan_acquire(void*);
  1567  extern void __tsan_release(void*);
  1568  
  1569  __attribute__ ((unused))
  1570  static void _cgo_tsan_acquire() {
  1571  	__tsan_acquire(&_cgo_sync);
  1572  }
  1573  
  1574  __attribute__ ((unused))
  1575  static void _cgo_tsan_release() {
  1576  	__tsan_release(&_cgo_sync);
  1577  }
  1578  `
  1579  
  1580  // Set to yesTsanProlog if we see -fsanitize=thread in the flags for gcc.
  1581  var tsanProlog = noTsanProlog
  1582  
  1583  // noMsanProlog is a prologue defining an MSAN function in C.
  1584  // This is used when not compiling with -fsanitize=memory.
  1585  const noMsanProlog = `
  1586  #define _cgo_msan_write(addr, sz)
  1587  `
  1588  
  1589  // yesMsanProlog is a prologue defining an MSAN function in C.
  1590  // This is used when compiling with -fsanitize=memory.
  1591  // See the comment above where _cgo_msan_write is called.
  1592  const yesMsanProlog = `
  1593  extern void __msan_unpoison(const volatile void *, size_t);
  1594  
  1595  #define _cgo_msan_write(addr, sz) __msan_unpoison((addr), (sz))
  1596  `
  1597  
  1598  // msanProlog is set to yesMsanProlog if we see -fsanitize=memory in the flags
  1599  // for the C compiler.
  1600  var msanProlog = noMsanProlog
  1601  
  1602  const builtinProlog = `
  1603  #line 1 "cgo-builtin-prolog"
  1604  #include <stddef.h> /* for ptrdiff_t and size_t below */
  1605  
  1606  /* Define intgo when compiling with GCC.  */
  1607  typedef ptrdiff_t intgo;
  1608  
  1609  #define GO_CGO_GOSTRING_TYPEDEF
  1610  typedef struct { const char *p; intgo n; } _GoString_;
  1611  typedef struct { char *p; intgo n; intgo c; } _GoBytes_;
  1612  _GoString_ GoString(char *p);
  1613  _GoString_ GoStringN(char *p, int l);
  1614  _GoBytes_ GoBytes(void *p, int n);
  1615  char *CString(_GoString_);
  1616  void *CBytes(_GoBytes_);
  1617  void *_CMalloc(size_t);
  1618  
  1619  __attribute__ ((unused))
  1620  static size_t _GoStringLen(_GoString_ s) { return (size_t)s.n; }
  1621  
  1622  __attribute__ ((unused))
  1623  static const char *_GoStringPtr(_GoString_ s) { return s.p; }
  1624  `
  1625  
  1626  const goProlog = `
  1627  //go:linkname _cgo_runtime_cgocall runtime.cgocall
  1628  func _cgo_runtime_cgocall(unsafe.Pointer, uintptr) int32
  1629  
  1630  //go:linkname _cgo_runtime_cgocallback runtime.cgocallback
  1631  func _cgo_runtime_cgocallback(unsafe.Pointer, unsafe.Pointer, uintptr, uintptr)
  1632  
  1633  //go:linkname _cgoCheckPointer runtime.cgoCheckPointer
  1634  func _cgoCheckPointer(interface{}, ...interface{})
  1635  
  1636  //go:linkname _cgoCheckResult runtime.cgoCheckResult
  1637  func _cgoCheckResult(interface{})
  1638  `
  1639  
  1640  const gccgoGoProlog = `
  1641  func _cgoCheckPointer(interface{}, ...interface{})
  1642  
  1643  func _cgoCheckResult(interface{})
  1644  `
  1645  
  1646  const goStringDef = `
  1647  //go:linkname _cgo_runtime_gostring runtime.gostring
  1648  func _cgo_runtime_gostring(*_Ctype_char) string
  1649  
  1650  func _Cfunc_GoString(p *_Ctype_char) string {
  1651  	return _cgo_runtime_gostring(p)
  1652  }
  1653  `
  1654  
  1655  const goStringNDef = `
  1656  //go:linkname _cgo_runtime_gostringn runtime.gostringn
  1657  func _cgo_runtime_gostringn(*_Ctype_char, int) string
  1658  
  1659  func _Cfunc_GoStringN(p *_Ctype_char, l _Ctype_int) string {
  1660  	return _cgo_runtime_gostringn(p, int(l))
  1661  }
  1662  `
  1663  
  1664  const goBytesDef = `
  1665  //go:linkname _cgo_runtime_gobytes runtime.gobytes
  1666  func _cgo_runtime_gobytes(unsafe.Pointer, int) []byte
  1667  
  1668  func _Cfunc_GoBytes(p unsafe.Pointer, l _Ctype_int) []byte {
  1669  	return _cgo_runtime_gobytes(p, int(l))
  1670  }
  1671  `
  1672  
  1673  const cStringDef = `
  1674  func _Cfunc_CString(s string) *_Ctype_char {
  1675  	p := _cgo_cmalloc(uint64(len(s)+1))
  1676  	pp := (*[1<<30]byte)(p)
  1677  	copy(pp[:], s)
  1678  	pp[len(s)] = 0
  1679  	return (*_Ctype_char)(p)
  1680  }
  1681  `
  1682  
  1683  const cBytesDef = `
  1684  func _Cfunc_CBytes(b []byte) unsafe.Pointer {
  1685  	p := _cgo_cmalloc(uint64(len(b)))
  1686  	pp := (*[1<<30]byte)(p)
  1687  	copy(pp[:], b)
  1688  	return p
  1689  }
  1690  `
  1691  
  1692  const cMallocDef = `
  1693  func _Cfunc__CMalloc(n _Ctype_size_t) unsafe.Pointer {
  1694  	return _cgo_cmalloc(uint64(n))
  1695  }
  1696  `
  1697  
  1698  var builtinDefs = map[string]string{
  1699  	"GoString":  goStringDef,
  1700  	"GoStringN": goStringNDef,
  1701  	"GoBytes":   goBytesDef,
  1702  	"CString":   cStringDef,
  1703  	"CBytes":    cBytesDef,
  1704  	"_CMalloc":  cMallocDef,
  1705  }
  1706  
  1707  // Definitions for C.malloc in Go and in C. We define it ourselves
  1708  // since we call it from functions we define, such as C.CString.
  1709  // Also, we have historically ensured that C.malloc does not return
  1710  // nil even for an allocation of 0.
  1711  
  1712  const cMallocDefGo = `
  1713  //go:cgo_import_static _cgoPREFIX_Cfunc__Cmalloc
  1714  //go:linkname __cgofn__cgoPREFIX_Cfunc__Cmalloc _cgoPREFIX_Cfunc__Cmalloc
  1715  var __cgofn__cgoPREFIX_Cfunc__Cmalloc byte
  1716  var _cgoPREFIX_Cfunc__Cmalloc = unsafe.Pointer(&__cgofn__cgoPREFIX_Cfunc__Cmalloc)
  1717  
  1718  //go:linkname runtime_throw runtime.throw
  1719  func runtime_throw(string)
  1720  
  1721  //go:cgo_unsafe_args
  1722  func _cgo_cmalloc(p0 uint64) (r1 unsafe.Pointer) {
  1723  	_cgo_runtime_cgocall(_cgoPREFIX_Cfunc__Cmalloc, uintptr(unsafe.Pointer(&p0)))
  1724  	if r1 == nil {
  1725  		runtime_throw("runtime: C malloc failed")
  1726  	}
  1727  	return
  1728  }
  1729  `
  1730  
  1731  // cMallocDefC defines the C version of C.malloc for the gc compiler.
  1732  // It is defined here because C.CString and friends need a definition.
  1733  // We define it by hand, rather than simply inventing a reference to
  1734  // C.malloc, because <stdlib.h> may not have been included.
  1735  // This is approximately what writeOutputFunc would generate, but
  1736  // skips the cgo_topofstack code (which is only needed if the C code
  1737  // calls back into Go). This also avoids returning nil for an
  1738  // allocation of 0 bytes.
  1739  const cMallocDefC = `
  1740  CGO_NO_SANITIZE_THREAD
  1741  void _cgoPREFIX_Cfunc__Cmalloc(void *v) {
  1742  	struct {
  1743  		unsigned long long p0;
  1744  		void *r1;
  1745  	} PACKED *a = v;
  1746  	void *ret;
  1747  	_cgo_tsan_acquire();
  1748  	ret = malloc(a->p0);
  1749  	if (ret == 0 && a->p0 == 0) {
  1750  		ret = malloc(1);
  1751  	}
  1752  	a->r1 = ret;
  1753  	_cgo_tsan_release();
  1754  }
  1755  `
  1756  
  1757  func (p *Package) cPrologGccgo() string {
  1758  	return strings.Replace(strings.Replace(cPrologGccgo, "PREFIX", cPrefix, -1),
  1759  		"GCCGOSYMBOLPREF", p.gccgoSymbolPrefix(), -1)
  1760  }
  1761  
  1762  const cPrologGccgo = `
  1763  #line 1 "cgo-c-prolog-gccgo"
  1764  #include <stdint.h>
  1765  #include <stdlib.h>
  1766  #include <string.h>
  1767  
  1768  typedef unsigned char byte;
  1769  typedef intptr_t intgo;
  1770  
  1771  struct __go_string {
  1772  	const unsigned char *__data;
  1773  	intgo __length;
  1774  };
  1775  
  1776  typedef struct __go_open_array {
  1777  	void* __values;
  1778  	intgo __count;
  1779  	intgo __capacity;
  1780  } Slice;
  1781  
  1782  struct __go_string __go_byte_array_to_string(const void* p, intgo len);
  1783  struct __go_open_array __go_string_to_byte_array (struct __go_string str);
  1784  
  1785  const char *_cgoPREFIX_Cfunc_CString(struct __go_string s) {
  1786  	char *p = malloc(s.__length+1);
  1787  	memmove(p, s.__data, s.__length);
  1788  	p[s.__length] = 0;
  1789  	return p;
  1790  }
  1791  
  1792  void *_cgoPREFIX_Cfunc_CBytes(struct __go_open_array b) {
  1793  	char *p = malloc(b.__count);
  1794  	memmove(p, b.__values, b.__count);
  1795  	return p;
  1796  }
  1797  
  1798  struct __go_string _cgoPREFIX_Cfunc_GoString(char *p) {
  1799  	intgo len = (p != NULL) ? strlen(p) : 0;
  1800  	return __go_byte_array_to_string(p, len);
  1801  }
  1802  
  1803  struct __go_string _cgoPREFIX_Cfunc_GoStringN(char *p, int32_t n) {
  1804  	return __go_byte_array_to_string(p, n);
  1805  }
  1806  
  1807  Slice _cgoPREFIX_Cfunc_GoBytes(char *p, int32_t n) {
  1808  	struct __go_string s = { (const unsigned char *)p, n };
  1809  	return __go_string_to_byte_array(s);
  1810  }
  1811  
  1812  extern void runtime_throw(const char *);
  1813  void *_cgoPREFIX_Cfunc__CMalloc(size_t n) {
  1814          void *p = malloc(n);
  1815          if(p == NULL && n == 0)
  1816                  p = malloc(1);
  1817          if(p == NULL)
  1818                  runtime_throw("runtime: C malloc failed");
  1819          return p;
  1820  }
  1821  
  1822  struct __go_type_descriptor;
  1823  typedef struct __go_empty_interface {
  1824  	const struct __go_type_descriptor *__type_descriptor;
  1825  	void *__object;
  1826  } Eface;
  1827  
  1828  extern void runtimeCgoCheckPointer(Eface, Slice)
  1829  	__asm__("runtime.cgoCheckPointer")
  1830  	__attribute__((weak));
  1831  
  1832  extern void localCgoCheckPointer(Eface, Slice)
  1833  	__asm__("GCCGOSYMBOLPREF._cgoCheckPointer");
  1834  
  1835  void localCgoCheckPointer(Eface ptr, Slice args) {
  1836  	if(runtimeCgoCheckPointer) {
  1837  		runtimeCgoCheckPointer(ptr, args);
  1838  	}
  1839  }
  1840  
  1841  extern void runtimeCgoCheckResult(Eface)
  1842  	__asm__("runtime.cgoCheckResult")
  1843  	__attribute__((weak));
  1844  
  1845  extern void localCgoCheckResult(Eface)
  1846  	__asm__("GCCGOSYMBOLPREF._cgoCheckResult");
  1847  
  1848  void localCgoCheckResult(Eface val) {
  1849  	if(runtimeCgoCheckResult) {
  1850  		runtimeCgoCheckResult(val);
  1851  	}
  1852  }
  1853  `
  1854  
  1855  // builtinExportProlog is a shorter version of builtinProlog,
  1856  // to be put into the _cgo_export.h file.
  1857  // For historical reasons we can't use builtinProlog in _cgo_export.h,
  1858  // because _cgo_export.h defines GoString as a struct while builtinProlog
  1859  // defines it as a function. We don't change this to avoid unnecessarily
  1860  // breaking existing code.
  1861  // The test of GO_CGO_GOSTRING_TYPEDEF avoids a duplicate definition
  1862  // error if a Go file with a cgo comment #include's the export header
  1863  // generated by a different package.
  1864  const builtinExportProlog = `
  1865  #line 1 "cgo-builtin-export-prolog"
  1866  
  1867  #include <stddef.h> /* for ptrdiff_t below */
  1868  
  1869  #ifndef GO_CGO_EXPORT_PROLOGUE_H
  1870  #define GO_CGO_EXPORT_PROLOGUE_H
  1871  
  1872  #ifndef GO_CGO_GOSTRING_TYPEDEF
  1873  typedef struct { const char *p; ptrdiff_t n; } _GoString_;
  1874  #endif
  1875  
  1876  #endif
  1877  `
  1878  
  1879  func (p *Package) gccExportHeaderProlog() string {
  1880  	return strings.Replace(gccExportHeaderProlog, "GOINTBITS", fmt.Sprint(8*p.IntSize), -1)
  1881  }
  1882  
  1883  // gccExportHeaderProlog is written to the exported header, after the
  1884  // import "C" comment preamble but before the generated declarations
  1885  // of exported functions. This permits the generated declarations to
  1886  // use the type names that appear in goTypes, above.
  1887  //
  1888  // The test of GO_CGO_GOSTRING_TYPEDEF avoids a duplicate definition
  1889  // error if a Go file with a cgo comment #include's the export header
  1890  // generated by a different package. Unfortunately GoString means two
  1891  // different things: in this prolog it means a C name for the Go type,
  1892  // while in the prolog written into the start of the C code generated
  1893  // from a cgo-using Go file it means the C.GoString function. There is
  1894  // no way to resolve this conflict, but it also doesn't make much
  1895  // difference, as Go code never wants to refer to the latter meaning.
  1896  const gccExportHeaderProlog = `
  1897  /* Start of boilerplate cgo prologue.  */
  1898  #line 1 "cgo-gcc-export-header-prolog"
  1899  
  1900  #ifndef GO_CGO_PROLOGUE_H
  1901  #define GO_CGO_PROLOGUE_H
  1902  
  1903  typedef signed char GoInt8;
  1904  typedef unsigned char GoUint8;
  1905  typedef short GoInt16;
  1906  typedef unsigned short GoUint16;
  1907  typedef int GoInt32;
  1908  typedef unsigned int GoUint32;
  1909  typedef long long GoInt64;
  1910  typedef unsigned long long GoUint64;
  1911  typedef GoIntGOINTBITS GoInt;
  1912  typedef GoUintGOINTBITS GoUint;
  1913  typedef __SIZE_TYPE__ GoUintptr;
  1914  typedef float GoFloat32;
  1915  typedef double GoFloat64;
  1916  typedef float _Complex GoComplex64;
  1917  typedef double _Complex GoComplex128;
  1918  
  1919  /*
  1920    static assertion to make sure the file is being used on architecture
  1921    at least with matching size of GoInt.
  1922  */
  1923  typedef char _check_for_GOINTBITS_bit_pointer_matching_GoInt[sizeof(void*)==GOINTBITS/8 ? 1:-1];
  1924  
  1925  #ifndef GO_CGO_GOSTRING_TYPEDEF
  1926  typedef _GoString_ GoString;
  1927  #endif
  1928  typedef void *GoMap;
  1929  typedef void *GoChan;
  1930  typedef struct { void *t; void *v; } GoInterface;
  1931  typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;
  1932  
  1933  #endif
  1934  
  1935  /* End of boilerplate cgo prologue.  */
  1936  
  1937  #ifdef __cplusplus
  1938  extern "C" {
  1939  #endif
  1940  `
  1941  
  1942  // gccExportHeaderEpilog goes at the end of the generated header file.
  1943  const gccExportHeaderEpilog = `
  1944  #ifdef __cplusplus
  1945  }
  1946  #endif
  1947  `
  1948  
  1949  // gccgoExportFileProlog is written to the _cgo_export.c file when
  1950  // using gccgo.
  1951  // We use weak declarations, and test the addresses, so that this code
  1952  // works with older versions of gccgo.
  1953  const gccgoExportFileProlog = `
  1954  #line 1 "cgo-gccgo-export-file-prolog"
  1955  extern _Bool runtime_iscgo __attribute__ ((weak));
  1956  
  1957  static void GoInit(void) __attribute__ ((constructor));
  1958  static void GoInit(void) {
  1959  	if(&runtime_iscgo)
  1960  		runtime_iscgo = 1;
  1961  }
  1962  
  1963  extern __SIZE_TYPE__ _cgo_wait_runtime_init_done(void) __attribute__ ((weak));
  1964  `
  1965  

View as plain text