main.go

     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  // Cgo; see doc.go for an overview.
     6  
     7  // TODO(rsc):
     8  //	Emit correct line number annotations.
     9  //	Make gc understand the annotations.
    10  
    11  package main
    12  
    13  import (
    14  	"crypto/md5"
    15  	"flag"
    16  	"fmt"
    17  	"go/ast"
    18  	"go/printer"
    19  	"go/token"
    20  	"internal/buildcfg"
    21  	"io"
    22  	"io/ioutil"
    23  	"os"
    24  	"path/filepath"
    25  	"reflect"
    26  	"runtime"
    27  	"sort"
    28  	"strings"
    29  
    30  	"cmd/internal/edit"
    31  	"cmd/internal/objabi"
    32  )
    33  
    34  // A Package collects information about the package we're going to write.
    35  type Package struct {
    36  	PackageName string // name of package
    37  	PackagePath string
    38  	PtrSize     int64
    39  	IntSize     int64
    40  	GccOptions  []string
    41  	GccIsClang  bool
    42  	CgoFlags    map[string][]string // #cgo flags (CFLAGS, LDFLAGS)
    43  	Written     map[string]bool
    44  	Name        map[string]*Name // accumulated Name from Files
    45  	ExpFunc     []*ExpFunc       // accumulated ExpFunc from Files
    46  	Decl        []ast.Decl
    47  	GoFiles     []string        // list of Go files
    48  	GccFiles    []string        // list of gcc output files
    49  	Preamble    string          // collected preamble for _cgo_export.h
    50  	typedefs    map[string]bool // type names that appear in the types of the objects we're interested in
    51  	typedefList []typedefInfo
    52  }
    53  
    54  // A typedefInfo is an element on Package.typedefList: a typedef name
    55  // and the position where it was required.
    56  type typedefInfo struct {
    57  	typedef string
    58  	pos     token.Pos
    59  }
    60  
    61  // A File collects information about a single Go input file.
    62  type File struct {
    63  	AST      *ast.File           // parsed AST
    64  	Comments []*ast.CommentGroup // comments from file
    65  	Package  string              // Package name
    66  	Preamble string              // C preamble (doc comment on import "C")
    67  	Ref      []*Ref              // all references to C.xxx in AST
    68  	Calls    []*Call             // all calls to C.xxx in AST
    69  	ExpFunc  []*ExpFunc          // exported functions for this file
    70  	Name     map[string]*Name    // map from Go name to Name
    71  	NamePos  map[*Name]token.Pos // map from Name to position of the first reference
    72  	Edit     *edit.Buffer
    73  }
    74  
    75  func (f *File) offset(p token.Pos) int {
    76  	return fset.Position(p).Offset
    77  }
    78  
    79  func nameKeys(m map[string]*Name) []string {
    80  	var ks []string
    81  	for k := range m {
    82  		ks = append(ks, k)
    83  	}
    84  	sort.Strings(ks)
    85  	return ks
    86  }
    87  
    88  // A Call refers to a call of a C.xxx function in the AST.
    89  type Call struct {
    90  	Call     *ast.CallExpr
    91  	Deferred bool
    92  	Done     bool
    93  }
    94  
    95  // A Ref refers to an expression of the form C.xxx in the AST.
    96  type Ref struct {
    97  	Name    *Name
    98  	Expr    *ast.Expr
    99  	Context astContext
   100  	Done    bool
   101  }
   102  
   103  func (r *Ref) Pos() token.Pos {
   104  	return (*r.Expr).Pos()
   105  }
   106  
   107  var nameKinds = []string{"iconst", "fconst", "sconst", "type", "var", "fpvar", "func", "macro", "not-type"}
   108  
   109  // A Name collects information about C.xxx.
   110  type Name struct {
   111  	Go       string // name used in Go referring to package C
   112  	Mangle   string // name used in generated Go
   113  	C        string // name used in C
   114  	Define   string // #define expansion
   115  	Kind     string // one of the nameKinds
   116  	Type     *Type  // the type of xxx
   117  	FuncType *FuncType
   118  	AddError bool
   119  	Const    string // constant definition
   120  }
   121  
   122  // IsVar reports whether Kind is either "var" or "fpvar"
   123  func (n *Name) IsVar() bool {
   124  	return n.Kind == "var" || n.Kind == "fpvar"
   125  }
   126  
   127  // IsConst reports whether Kind is either "iconst", "fconst" or "sconst"
   128  func (n *Name) IsConst() bool {
   129  	return strings.HasSuffix(n.Kind, "const")
   130  }
   131  
   132  // An ExpFunc is an exported function, callable from C.
   133  // Such functions are identified in the Go input file
   134  // by doc comments containing the line //export ExpName
   135  type ExpFunc struct {
   136  	Func    *ast.FuncDecl
   137  	ExpName string // name to use from C
   138  	Doc     string
   139  }
   140  
   141  // A TypeRepr contains the string representation of a type.
   142  type TypeRepr struct {
   143  	Repr       string
   144  	FormatArgs []interface{}
   145  }
   146  
   147  // A Type collects information about a type in both the C and Go worlds.
   148  type Type struct {
   149  	Size       int64
   150  	Align      int64
   151  	C          *TypeRepr
   152  	Go         ast.Expr
   153  	EnumValues map[string]int64
   154  	Typedef    string
   155  	BadPointer bool // this pointer type should be represented as a uintptr (deprecated)
   156  	NotInHeap  bool // this type should have a go:notinheap annotation
   157  }
   158  
   159  // A FuncType collects information about a function type in both the C and Go worlds.
   160  type FuncType struct {
   161  	Params []*Type
   162  	Result *Type
   163  	Go     *ast.FuncType
   164  }
   165  
   166  func usage() {
   167  	fmt.Fprint(os.Stderr, "usage: cgo -- [compiler options] file.go ...\n")
   168  	flag.PrintDefaults()
   169  	os.Exit(2)
   170  }
   171  
   172  var ptrSizeMap = map[string]int64{
   173  	"386":      4,
   174  	"alpha":    8,
   175  	"amd64":    8,
   176  	"arm":      4,
   177  	"arm64":    8,
   178  	"m68k":     4,
   179  	"mips":     4,
   180  	"mipsle":   4,
   181  	"mips64":   8,
   182  	"mips64le": 8,
   183  	"nios2":    4,
   184  	"ppc":      4,
   185  	"ppc64":    8,
   186  	"ppc64le":  8,
   187  	"riscv":    4,
   188  	"riscv64":  8,
   189  	"s390":     4,
   190  	"s390x":    8,
   191  	"sh":       4,
   192  	"shbe":     4,
   193  	"sparc":    4,
   194  	"sparc64":  8,
   195  }
   196  
   197  var intSizeMap = map[string]int64{
   198  	"386":      4,
   199  	"alpha":    8,
   200  	"amd64":    8,
   201  	"arm":      4,
   202  	"arm64":    8,
   203  	"m68k":     4,
   204  	"mips":     4,
   205  	"mipsle":   4,
   206  	"mips64":   8,
   207  	"mips64le": 8,
   208  	"nios2":    4,
   209  	"ppc":      4,
   210  	"ppc64":    8,
   211  	"ppc64le":  8,
   212  	"riscv":    4,
   213  	"riscv64":  8,
   214  	"s390":     4,
   215  	"s390x":    8,
   216  	"sh":       4,
   217  	"shbe":     4,
   218  	"sparc":    4,
   219  	"sparc64":  8,
   220  }
   221  
   222  var cPrefix string
   223  
   224  var fset = token.NewFileSet()
   225  
   226  var dynobj = flag.String("dynimport", "", "if non-empty, print dynamic import data for that file")
   227  var dynout = flag.String("dynout", "", "write -dynimport output to this file")
   228  var dynpackage = flag.String("dynpackage", "main", "set Go package for -dynimport output")
   229  var dynlinker = flag.Bool("dynlinker", false, "record dynamic linker information in -dynimport mode")
   230  
   231  // This flag is for bootstrapping a new Go implementation,
   232  // to generate Go types that match the data layout and
   233  // constant values used in the host's C libraries and system calls.
   234  var godefs = flag.Bool("godefs", false, "for bootstrap: write Go definitions for C file to standard output")
   235  
   236  var srcDir = flag.String("srcdir", "", "source directory")
   237  var objDir = flag.String("objdir", "", "object directory")
   238  var importPath = flag.String("importpath", "", "import path of package being built (for comments in generated files)")
   239  var exportHeader = flag.String("exportheader", "", "where to write export header if any exported functions")
   240  
   241  var gccgo = flag.Bool("gccgo", false, "generate files for use with gccgo")
   242  var gccgoprefix = flag.String("gccgoprefix", "", "-fgo-prefix option used with gccgo")
   243  var gccgopkgpath = flag.String("gccgopkgpath", "", "-fgo-pkgpath option used with gccgo")
   244  var gccgoMangler func(string) string
   245  var importRuntimeCgo = flag.Bool("import_runtime_cgo", true, "import runtime/cgo in generated code")
   246  var importSyscall = flag.Bool("import_syscall", true, "import syscall in generated code")
   247  var trimpath = flag.String("trimpath", "", "applies supplied rewrites or trims prefixes to recorded source file paths")
   248  
   249  var goarch, goos, gomips, gomips64 string
   250  var gccBaseCmd []string
   251  
   252  func main() {
   253  	objabi.AddVersionFlag() // -V
   254  	flag.Usage = usage
   255  	flag.Parse()
   256  
   257  	if *dynobj != "" {
   258  		// cgo -dynimport is essentially a separate helper command
   259  		// built into the cgo binary. It scans a gcc-produced executable
   260  		// and dumps information about the imported symbols and the
   261  		// imported libraries. The 'go build' rules for cgo prepare an
   262  		// appropriate executable and then use its import information
   263  		// instead of needing to make the linkers duplicate all the
   264  		// specialized knowledge gcc has about where to look for imported
   265  		// symbols and which ones to use.
   266  		dynimport(*dynobj)
   267  		return
   268  	}
   269  
   270  	if *godefs {
   271  		// Generating definitions pulled from header files,
   272  		// to be checked into Go repositories.
   273  		// Line numbers are just noise.
   274  		conf.Mode &^= printer.SourcePos
   275  	}
   276  
   277  	args := flag.Args()
   278  	if len(args) < 1 {
   279  		usage()
   280  	}
   281  
   282  	// Find first arg that looks like a go file and assume everything before
   283  	// that are options to pass to gcc.
   284  	var i int
   285  	for i = len(args); i > 0; i-- {
   286  		if !strings.HasSuffix(args[i-1], ".go") {
   287  			break
   288  		}
   289  	}
   290  	if i == len(args) {
   291  		usage()
   292  	}
   293  
   294  	goFiles := args[i:]
   295  
   296  	for _, arg := range args[:i] {
   297  		if arg == "-fsanitize=thread" {
   298  			tsanProlog = yesTsanProlog
   299  		}
   300  		if arg == "-fsanitize=memory" {
   301  			msanProlog = yesMsanProlog
   302  		}
   303  	}
   304  
   305  	p := newPackage(args[:i])
   306  
   307  	// We need a C compiler to be available. Check this.
   308  	var err error
   309  	gccBaseCmd, err = checkGCCBaseCmd()
   310  	if err != nil {
   311  		fatalf("%v", err)
   312  		os.Exit(2)
   313  	}
   314  
   315  	// Record CGO_LDFLAGS from the environment for external linking.
   316  	if ldflags := os.Getenv("CGO_LDFLAGS"); ldflags != "" {
   317  		args, err := splitQuoted(ldflags)
   318  		if err != nil {
   319  			fatalf("bad CGO_LDFLAGS: %q (%s)", ldflags, err)
   320  		}
   321  		p.addToFlag("LDFLAGS", args)
   322  	}
   323  
   324  	// Need a unique prefix for the global C symbols that
   325  	// we use to coordinate between gcc and ourselves.
   326  	// We already put _cgo_ at the beginning, so the main
   327  	// concern is other cgo wrappers for the same functions.
   328  	// Use the beginning of the md5 of the input to disambiguate.
   329  	h := md5.New()
   330  	io.WriteString(h, *importPath)
   331  	fs := make([]*File, len(goFiles))
   332  	for i, input := range goFiles {
   333  		if *srcDir != "" {
   334  			input = filepath.Join(*srcDir, input)
   335  		}
   336  
   337  		// Create absolute path for file, so that it will be used in error
   338  		// messages and recorded in debug line number information.
   339  		// This matches the rest of the toolchain. See golang.org/issue/5122.
   340  		if aname, err := filepath.Abs(input); err == nil {
   341  			input = aname
   342  		}
   343  
   344  		b, err := ioutil.ReadFile(input)
   345  		if err != nil {
   346  			fatalf("%s", err)
   347  		}
   348  		if _, err = h.Write(b); err != nil {
   349  			fatalf("%s", err)
   350  		}
   351  
   352  		// Apply trimpath to the file path. The path won't be read from after this point.
   353  		input, _ = objabi.ApplyRewrites(input, *trimpath)
   354  		goFiles[i] = input
   355  
   356  		f := new(File)
   357  		f.Edit = edit.NewBuffer(b)
   358  		f.ParseGo(input, b)
   359  		f.DiscardCgoDirectives()
   360  		fs[i] = f
   361  	}
   362  
   363  	cPrefix = fmt.Sprintf("_%x", h.Sum(nil)[0:6])
   364  
   365  	if *objDir == "" {
   366  		// make sure that _obj directory exists, so that we can write
   367  		// all the output files there.
   368  		os.Mkdir("_obj", 0777)
   369  		*objDir = "_obj"
   370  	}
   371  	*objDir += string(filepath.Separator)
   372  
   373  	for i, input := range goFiles {
   374  		f := fs[i]
   375  		p.Translate(f)
   376  		for _, cref := range f.Ref {
   377  			switch cref.Context {
   378  			case ctxCall, ctxCall2:
   379  				if cref.Name.Kind != "type" {
   380  					break
   381  				}
   382  				old := *cref.Expr
   383  				*cref.Expr = cref.Name.Type.Go
   384  				f.Edit.Replace(f.offset(old.Pos()), f.offset(old.End()), gofmt(cref.Name.Type.Go))
   385  			}
   386  		}
   387  		if nerrors > 0 {
   388  			os.Exit(2)
   389  		}
   390  		p.PackagePath = f.Package
   391  		p.Record(f)
   392  		if *godefs {
   393  			os.Stdout.WriteString(p.godefs(f))
   394  		} else {
   395  			p.writeOutput(f, input)
   396  		}
   397  	}
   398  
   399  	if !*godefs {
   400  		p.writeDefs()
   401  	}
   402  	if nerrors > 0 {
   403  		os.Exit(2)
   404  	}
   405  }
   406  
   407  // newPackage returns a new Package that will invoke
   408  // gcc with the additional arguments specified in args.
   409  func newPackage(args []string) *Package {
   410  	goarch = runtime.GOARCH
   411  	if s := os.Getenv("GOARCH"); s != "" {
   412  		goarch = s
   413  	}
   414  	goos = runtime.GOOS
   415  	if s := os.Getenv("GOOS"); s != "" {
   416  		goos = s
   417  	}
   418  	buildcfg.Check()
   419  	gomips = buildcfg.GOMIPS
   420  	gomips64 = buildcfg.GOMIPS64
   421  	ptrSize := ptrSizeMap[goarch]
   422  	if ptrSize == 0 {
   423  		fatalf("unknown ptrSize for $GOARCH %q", goarch)
   424  	}
   425  	intSize := intSizeMap[goarch]
   426  	if intSize == 0 {
   427  		fatalf("unknown intSize for $GOARCH %q", goarch)
   428  	}
   429  
   430  	// Reset locale variables so gcc emits English errors [sic].
   431  	os.Setenv("LANG", "en_US.UTF-8")
   432  	os.Setenv("LC_ALL", "C")
   433  
   434  	p := &Package{
   435  		PtrSize:  ptrSize,
   436  		IntSize:  intSize,
   437  		CgoFlags: make(map[string][]string),
   438  		Written:  make(map[string]bool),
   439  	}
   440  	p.addToFlag("CFLAGS", args)
   441  	return p
   442  }
   443  
   444  // Record what needs to be recorded about f.
   445  func (p *Package) Record(f *File) {
   446  	if p.PackageName == "" {
   447  		p.PackageName = f.Package
   448  	} else if p.PackageName != f.Package {
   449  		error_(token.NoPos, "inconsistent package names: %s, %s", p.PackageName, f.Package)
   450  	}
   451  
   452  	if p.Name == nil {
   453  		p.Name = f.Name
   454  	} else {
   455  		for k, v := range f.Name {
   456  			if p.Name[k] == nil {
   457  				p.Name[k] = v
   458  			} else if p.incompleteTypedef(p.Name[k].Type) {
   459  				p.Name[k] = v
   460  			} else if p.incompleteTypedef(v.Type) {
   461  				// Nothing to do.
   462  			} else if _, ok := nameToC[k]; ok {
   463  				// Names we predefine may appear inconsistent
   464  				// if some files typedef them and some don't.
   465  				// Issue 26743.
   466  			} else if !reflect.DeepEqual(p.Name[k], v) {
   467  				error_(token.NoPos, "inconsistent definitions for C.%s", fixGo(k))
   468  			}
   469  		}
   470  	}
   471  
   472  	if f.ExpFunc != nil {
   473  		p.ExpFunc = append(p.ExpFunc, f.ExpFunc...)
   474  		p.Preamble += "\n" + f.Preamble
   475  	}
   476  	p.Decl = append(p.Decl, f.AST.Decls...)
   477  }
   478  
   479  // incompleteTypedef reports whether t appears to be an incomplete
   480  // typedef definition.
   481  func (p *Package) incompleteTypedef(t *Type) bool {
   482  	return t == nil || (t.Size == 0 && t.Align == -1)
   483  }
   484
View as plain text