Source file
src/cmd/cgo/main.go
Documentation: cmd/cgo
1
2
3
4
5
6
7
8
9
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
34 type Package struct {
35 PackageName string
36 PackagePath string
37 PtrSize int64
38 IntSize int64
39 GccOptions []string
40 GccIsClang bool
41 CgoFlags map[string][]string
42 Written map[string]bool
43 Name map[string]*Name
44 ExpFunc []*ExpFunc
45 Decl []ast.Decl
46 GoFiles []string
47 GccFiles []string
48 Preamble string
49 typedefs map[string]bool
50 typedefList []typedefInfo
51 }
52
53
54
55 type typedefInfo struct {
56 typedef string
57 pos token.Pos
58 }
59
60
61 type File struct {
62 AST *ast.File
63 Comments []*ast.CommentGroup
64 Package string
65 Preamble string
66 Ref []*Ref
67 Calls []*Call
68 ExpFunc []*ExpFunc
69 Name map[string]*Name
70 NamePos map[*Name]token.Pos
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
88 type Call struct {
89 Call *ast.CallExpr
90 Deferred bool
91 Done bool
92 }
93
94
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
109 type Name struct {
110 Go string
111 Mangle string
112 C string
113 Define string
114 Kind string
115 Type *Type
116 FuncType *FuncType
117 AddError bool
118 Const string
119 }
120
121
122 func (n *Name) IsVar() bool {
123 return n.Kind == "var" || n.Kind == "fpvar"
124 }
125
126
127 func (n *Name) IsConst() bool {
128 return strings.HasSuffix(n.Kind, "const")
129 }
130
131
132
133
134 type ExpFunc struct {
135 Func *ast.FuncDecl
136 ExpName string
137 Doc string
138 }
139
140
141 type TypeRepr struct {
142 Repr string
143 FormatArgs []interface{}
144 }
145
146
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 NotInHeap bool
156 }
157
158
159 type FuncType struct {
160 Params []*Type
161 Result *Type
162 Go *ast.FuncType
163 }
164
165 func usage() {
166 fmt.Fprint(os.Stderr, "usage: cgo -- [compiler options] file.go ...\n")
167 flag.PrintDefaults()
168 os.Exit(2)
169 }
170
171 var ptrSizeMap = map[string]int64{
172 "386": 4,
173 "alpha": 8,
174 "amd64": 8,
175 "arm": 4,
176 "arm64": 8,
177 "m68k": 4,
178 "mips": 4,
179 "mipsle": 4,
180 "mips64": 8,
181 "mips64le": 8,
182 "nios2": 4,
183 "ppc": 4,
184 "ppc64": 8,
185 "ppc64le": 8,
186 "riscv": 4,
187 "riscv64": 8,
188 "s390": 4,
189 "s390x": 8,
190 "sh": 4,
191 "shbe": 4,
192 "sparc": 4,
193 "sparc64": 8,
194 }
195
196 var intSizeMap = map[string]int64{
197 "386": 4,
198 "alpha": 8,
199 "amd64": 8,
200 "arm": 4,
201 "arm64": 8,
202 "m68k": 4,
203 "mips": 4,
204 "mipsle": 4,
205 "mips64": 8,
206 "mips64le": 8,
207 "nios2": 4,
208 "ppc": 4,
209 "ppc64": 8,
210 "ppc64le": 8,
211 "riscv": 4,
212 "riscv64": 8,
213 "s390": 4,
214 "s390x": 8,
215 "sh": 4,
216 "shbe": 4,
217 "sparc": 4,
218 "sparc64": 8,
219 }
220
221 var cPrefix string
222
223 var fset = token.NewFileSet()
224
225 var dynobj = flag.String("dynimport", "", "if non-empty, print dynamic import data for that file")
226 var dynout = flag.String("dynout", "", "write -dynimport output to this file")
227 var dynpackage = flag.String("dynpackage", "main", "set Go package for -dynimport output")
228 var dynlinker = flag.Bool("dynlinker", false, "record dynamic linker information in -dynimport mode")
229
230
231
232
233 var godefs = flag.Bool("godefs", false, "for bootstrap: write Go definitions for C file to standard output")
234
235 var srcDir = flag.String("srcdir", "", "source directory")
236 var objDir = flag.String("objdir", "", "object directory")
237 var importPath = flag.String("importpath", "", "import path of package being built (for comments in generated files)")
238 var exportHeader = flag.String("exportheader", "", "where to write export header if any exported functions")
239
240 var gccgo = flag.Bool("gccgo", false, "generate files for use with gccgo")
241 var gccgoprefix = flag.String("gccgoprefix", "", "-fgo-prefix option used with gccgo")
242 var gccgopkgpath = flag.String("gccgopkgpath", "", "-fgo-pkgpath option used with gccgo")
243 var gccgoMangler func(string) string
244 var importRuntimeCgo = flag.Bool("import_runtime_cgo", true, "import runtime/cgo in generated code")
245 var importSyscall = flag.Bool("import_syscall", true, "import syscall in generated code")
246 var trimpath = flag.String("trimpath", "", "applies supplied rewrites or trims prefixes to recorded source file paths")
247
248 var goarch, goos string
249
250 func main() {
251 objabi.AddVersionFlag()
252 flag.Usage = usage
253 flag.Parse()
254
255 if *dynobj != "" {
256
257
258
259
260
261
262
263
264 dynimport(*dynobj)
265 return
266 }
267
268 if *godefs {
269
270
271
272 conf.Mode &^= printer.SourcePos
273 }
274
275 args := flag.Args()
276 if len(args) < 1 {
277 usage()
278 }
279
280
281
282 var i int
283 for i = len(args); i > 0; i-- {
284 if !strings.HasSuffix(args[i-1], ".go") {
285 break
286 }
287 }
288 if i == len(args) {
289 usage()
290 }
291
292 goFiles := args[i:]
293
294 for _, arg := range args[:i] {
295 if arg == "-fsanitize=thread" {
296 tsanProlog = yesTsanProlog
297 }
298 if arg == "-fsanitize=memory" {
299 msanProlog = yesMsanProlog
300 }
301 }
302
303 p := newPackage(args[:i])
304
305
306 if ldflags := os.Getenv("CGO_LDFLAGS"); ldflags != "" {
307 args, err := splitQuoted(ldflags)
308 if err != nil {
309 fatalf("bad CGO_LDFLAGS: %q (%s)", ldflags, err)
310 }
311 p.addToFlag("LDFLAGS", args)
312 }
313
314
315
316
317
318
319 h := md5.New()
320 io.WriteString(h, *importPath)
321 fs := make([]*File, len(goFiles))
322 for i, input := range goFiles {
323 if *srcDir != "" {
324 input = filepath.Join(*srcDir, input)
325 }
326
327
328
329
330 if aname, err := filepath.Abs(input); err == nil {
331 input = aname
332 }
333
334 b, err := ioutil.ReadFile(input)
335 if err != nil {
336 fatalf("%s", err)
337 }
338 if _, err = h.Write(b); err != nil {
339 fatalf("%s", err)
340 }
341
342
343 input, _ = objabi.ApplyRewrites(input, *trimpath)
344 goFiles[i] = input
345
346 f := new(File)
347 f.Edit = edit.NewBuffer(b)
348 f.ParseGo(input, b)
349 f.DiscardCgoDirectives()
350 fs[i] = f
351 }
352
353 cPrefix = fmt.Sprintf("_%x", h.Sum(nil)[0:6])
354
355 if *objDir == "" {
356
357
358 os.Mkdir("_obj", 0777)
359 *objDir = "_obj"
360 }
361 *objDir += string(filepath.Separator)
362
363 for i, input := range goFiles {
364 f := fs[i]
365 p.Translate(f)
366 for _, cref := range f.Ref {
367 switch cref.Context {
368 case ctxCall, ctxCall2:
369 if cref.Name.Kind != "type" {
370 break
371 }
372 old := *cref.Expr
373 *cref.Expr = cref.Name.Type.Go
374 f.Edit.Replace(f.offset(old.Pos()), f.offset(old.End()), gofmt(cref.Name.Type.Go))
375 }
376 }
377 if nerrors > 0 {
378 os.Exit(2)
379 }
380 p.PackagePath = f.Package
381 p.Record(f)
382 if *godefs {
383 os.Stdout.WriteString(p.godefs(f))
384 } else {
385 p.writeOutput(f, input)
386 }
387 }
388
389 if !*godefs {
390 p.writeDefs()
391 }
392 if nerrors > 0 {
393 os.Exit(2)
394 }
395 }
396
397
398
399 func newPackage(args []string) *Package {
400 goarch = runtime.GOARCH
401 if s := os.Getenv("GOARCH"); s != "" {
402 goarch = s
403 }
404 goos = runtime.GOOS
405 if s := os.Getenv("GOOS"); s != "" {
406 goos = s
407 }
408 ptrSize := ptrSizeMap[goarch]
409 if ptrSize == 0 {
410 fatalf("unknown ptrSize for $GOARCH %q", goarch)
411 }
412 intSize := intSizeMap[goarch]
413 if intSize == 0 {
414 fatalf("unknown intSize for $GOARCH %q", goarch)
415 }
416
417
418 os.Setenv("LANG", "en_US.UTF-8")
419 os.Setenv("LC_ALL", "C")
420
421 p := &Package{
422 PtrSize: ptrSize,
423 IntSize: intSize,
424 CgoFlags: make(map[string][]string),
425 Written: make(map[string]bool),
426 }
427 p.addToFlag("CFLAGS", args)
428 return p
429 }
430
431
432 func (p *Package) Record(f *File) {
433 if p.PackageName == "" {
434 p.PackageName = f.Package
435 } else if p.PackageName != f.Package {
436 error_(token.NoPos, "inconsistent package names: %s, %s", p.PackageName, f.Package)
437 }
438
439 if p.Name == nil {
440 p.Name = f.Name
441 } else {
442 for k, v := range f.Name {
443 if p.Name[k] == nil {
444 p.Name[k] = v
445 } else if p.incompleteTypedef(p.Name[k].Type) {
446 p.Name[k] = v
447 } else if p.incompleteTypedef(v.Type) {
448
449 } else if _, ok := nameToC[k]; ok {
450
451
452
453 } else if !reflect.DeepEqual(p.Name[k], v) {
454 error_(token.NoPos, "inconsistent definitions for C.%s", fixGo(k))
455 }
456 }
457 }
458
459 if f.ExpFunc != nil {
460 p.ExpFunc = append(p.ExpFunc, f.ExpFunc...)
461 p.Preamble += "\n" + f.Preamble
462 }
463 p.Decl = append(p.Decl, f.AST.Decls...)
464 }
465
466
467
468 func (p *Package) incompleteTypedef(t *Type) bool {
469 return t == nil || (t.Size == 0 && t.Align == -1)
470 }
471
View as plain text