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