1
2
3
4
5
6
7 package work
8
9 import (
10 "bytes"
11 "cmd/internal/cov/covcmd"
12 "cmd/internal/pathcache"
13 "cmp"
14 "context"
15 "crypto/sha256"
16 "encoding/json"
17 "errors"
18 "fmt"
19 "go/token"
20 "internal/lazyregexp"
21 "io"
22 "io/fs"
23 "log"
24 "math/rand"
25 "os"
26 "os/exec"
27 "path/filepath"
28 "regexp"
29 "runtime"
30 "slices"
31 "sort"
32 "strconv"
33 "strings"
34 "sync"
35 "time"
36
37 "cmd/go/internal/base"
38 "cmd/go/internal/cache"
39 "cmd/go/internal/cfg"
40 "cmd/go/internal/fsys"
41 "cmd/go/internal/gover"
42 "cmd/go/internal/load"
43 "cmd/go/internal/modinfo"
44 "cmd/go/internal/modload"
45 "cmd/go/internal/str"
46 "cmd/go/internal/trace"
47 "cmd/internal/buildid"
48 "cmd/internal/quoted"
49 "cmd/internal/sys"
50 )
51
52 const DefaultCFlags = "-O2 -g"
53
54
55
56 func actionList(root *Action) []*Action {
57 seen := map[*Action]bool{}
58 all := []*Action{}
59 var walk func(*Action)
60 walk = func(a *Action) {
61 if seen[a] {
62 return
63 }
64 seen[a] = true
65 for _, a1 := range a.Deps {
66 walk(a1)
67 }
68 all = append(all, a)
69 }
70 walk(root)
71 return all
72 }
73
74
75 func (b *Builder) Do(ctx context.Context, root *Action) {
76 ctx, span := trace.StartSpan(ctx, "exec.Builder.Do ("+root.Mode+" "+root.Target+")")
77 defer span.Done()
78
79 if !b.IsCmdList {
80
81 c := cache.Default()
82 defer func() {
83 if err := c.Close(); err != nil {
84 base.Fatalf("go: failed to trim cache: %v", err)
85 }
86 }()
87 }
88
89
90
91
92
93
94
95
96
97
98
99
100 all := actionList(root)
101 for i, a := range all {
102 a.priority = i
103 }
104 if cfg.Experiment.VetFiles {
105 b.prioritizeAnalysisTool(all)
106 }
107
108
109 writeActionGraph := func() {
110 if file := cfg.DebugActiongraph; file != "" {
111 if strings.HasSuffix(file, ".go") {
112
113
114 base.Fatalf("go: refusing to write action graph to %v\n", file)
115 }
116 js := actionGraphJSON(root)
117 if err := os.WriteFile(file, []byte(js), 0666); err != nil {
118 fmt.Fprintf(os.Stderr, "go: writing action graph: %v\n", err)
119 base.SetExitStatus(1)
120 }
121 }
122 }
123 writeActionGraph()
124
125 b.readySema = make(chan bool, len(all))
126
127
128 for _, a := range all {
129 for _, a1 := range a.Deps {
130 a1.triggers = append(a1.triggers, a)
131 }
132 a.pending = len(a.Deps)
133 if a.pending == 0 {
134 b.ready.push(a)
135 b.readySema <- true
136 }
137 }
138
139
140
141 handle := func(ctx context.Context, a *Action) {
142 if a.json != nil {
143 a.json.TimeStart = time.Now()
144 }
145 var err error
146 if a.Actor != nil && (a.Failed == nil || a.IgnoreFail) {
147
148 desc := "Executing action (" + a.Mode
149 if a.Package != nil {
150 desc += " " + a.Package.Desc()
151 }
152 desc += ")"
153 ctx, span := trace.StartSpan(ctx, desc)
154 a.traceSpan = span
155 for _, d := range a.Deps {
156 trace.Flow(ctx, d.traceSpan, a.traceSpan)
157 }
158 err = a.Actor.Act(b, ctx, a)
159 span.Done()
160 }
161 if a.json != nil {
162 a.json.TimeDone = time.Now()
163 }
164
165
166
167 b.exec.Lock()
168 defer b.exec.Unlock()
169
170 if err != nil {
171 if b.AllowErrors && a.Package != nil {
172 if a.Package.Error == nil {
173 a.Package.Error = &load.PackageError{Err: err}
174 a.Package.Incomplete = true
175 }
176 } else {
177 if a.Package != nil {
178 if ipe, ok := errors.AsType[load.ImportPathError](err); !ok || ipe.ImportPath() != a.Package.ImportPath {
179 err = fmt.Errorf("%s: %v", a.Package.ImportPath, err)
180 }
181 }
182 sh := b.Shell(a)
183 sh.Errorf("%s", err)
184 }
185 if a.Failed == nil {
186 a.Failed = a
187 }
188 }
189
190 for _, a0 := range a.triggers {
191 if a.Failed != nil {
192 if a0.Mode == "test barrier" {
193
194
195
196
197
198
199 for _, bt := range a0.triggers {
200 if bt.Mode != "test barrier" {
201 bt.Failed = a.Failed
202 }
203 }
204 } else {
205 a0.Failed = a.Failed
206 }
207 }
208 if a0.pending--; a0.pending == 0 {
209 b.ready.push(a0)
210 b.readySema <- true
211 }
212 }
213
214 if a == root {
215 close(b.readySema)
216 }
217 }
218
219 var wg sync.WaitGroup
220
221
222
223
224
225 par := cfg.BuildP
226 if cfg.BuildN {
227 par = 1
228 }
229 for i := 0; i < par; i++ {
230 wg.Add(1)
231 go func() {
232 ctx := trace.StartGoroutine(ctx)
233 defer wg.Done()
234 for {
235 select {
236 case _, ok := <-b.readySema:
237 if !ok {
238 return
239 }
240
241
242 b.exec.Lock()
243 a := b.ready.pop()
244 b.exec.Unlock()
245 handle(ctx, a)
246 case <-base.Interrupted:
247 base.SetExitStatus(1)
248 return
249 }
250 }
251 }()
252 }
253
254 wg.Wait()
255
256 if tokens != totalTokens || concurrentProcesses != 0 {
257 base.Fatalf("internal error: tokens not restored at end of build: tokens: %d, totalTokens: %d, concurrentProcesses: %d",
258 tokens, totalTokens, concurrentProcesses)
259 }
260
261
262 writeActionGraph()
263 }
264
265
266 func (b *Builder) buildActionID(a *Action) cache.ActionID {
267 p := a.Package
268 h := cache.NewHash("build " + p.ImportPath)
269
270
271
272
273
274
275 fmt.Fprintf(h, "compile\n")
276
277 b.addPackageOrigin(h, p)
278
279 if p.Module != nil {
280 fmt.Fprintf(h, "go %s\n", p.Module.GoVersion)
281 }
282 fmt.Fprintf(h, "goos %s goarch %s\n", cfg.Goos, cfg.Goarch)
283 fmt.Fprintf(h, "import %q\n", p.ImportPath)
284 fmt.Fprintf(h, "omitdebug %v standard %v local %v prefix %q\n", p.Internal.OmitDebug, p.Standard, p.Internal.Local, p.Internal.LocalPrefix)
285 if p.Internal.ForceLibrary {
286 fmt.Fprintf(h, "forcelibrary\n")
287 }
288 b.addCToolchainIDs(h, p)
289 if p.Internal.Cover.Mode != "" {
290 fmt.Fprintf(h, "cover %q %q\n", p.Internal.Cover.Mode, b.toolID("cover"))
291 }
292 if p.Internal.FuzzInstrument {
293 if fuzzFlags := fuzzInstrumentFlags(); fuzzFlags != nil {
294 fmt.Fprintf(h, "fuzz %q\n", fuzzFlags)
295 }
296 }
297 if p.Internal.BuildInfo != nil {
298 fmt.Fprintf(h, "modinfo %q\n", p.Internal.BuildInfo.String())
299 }
300
301
302 switch cfg.BuildToolchainName {
303 default:
304 base.Fatalf("buildActionID: unknown build toolchain %q", cfg.BuildToolchainName)
305 case "gc":
306 fmt.Fprintf(h, "compile %s %q %q\n", b.toolID("compile"), forcedGcflags, p.Internal.Gcflags)
307 if len(p.SFiles) > 0 {
308 fmt.Fprintf(h, "asm %q %q %q\n", b.toolID("asm"), forcedAsmflags, p.Internal.Asmflags)
309 }
310
311
312 key, val, _ := cfg.GetArchEnv()
313 fmt.Fprintf(h, "%s=%s\n", key, val)
314
315 if cfg.CleanGOEXPERIMENT != "" {
316 fmt.Fprintf(h, "GOEXPERIMENT=%q\n", cfg.CleanGOEXPERIMENT)
317 }
318
319
320
321
322
323
324 magic := []string{
325 "GOCLOBBERDEADHASH",
326 "GOSSAFUNC",
327 "GOSSADIR",
328 "GOCOMPILEDEBUG",
329 }
330 for _, env := range magic {
331 if x := os.Getenv(env); x != "" {
332 fmt.Fprintf(h, "magic %s=%s\n", env, x)
333 }
334 }
335
336 case "gccgo":
337 id, _, err := b.gccgoToolID(BuildToolchain.compiler(), "go")
338 if err != nil {
339 base.Fatalf("%v", err)
340 }
341 fmt.Fprintf(h, "compile %s %q %q\n", id, forcedGccgoflags, p.Internal.Gccgoflags)
342 fmt.Fprintf(h, "pkgpath %s\n", gccgoPkgpath(p))
343 fmt.Fprintf(h, "ar %q\n", BuildToolchain.(gccgoToolchain).ar())
344 if len(p.SFiles) > 0 {
345 id, _, _ = b.gccgoToolID(BuildToolchain.compiler(), "assembler-with-cpp")
346
347
348 fmt.Fprintf(h, "asm %q\n", id)
349 }
350 }
351
352
353
354
355 inputFiles := slices.Concat(
356 p.GoFiles,
357 p.CgoFiles,
358 p.CFiles,
359 p.CXXFiles,
360 p.FFiles,
361 p.MFiles,
362 p.HFiles,
363 p.SFiles,
364 p.SysoFiles,
365 p.SwigFiles,
366 p.SwigCXXFiles,
367 p.EmbedFiles,
368 )
369 for _, file := range inputFiles {
370 fmt.Fprintf(h, "file %s %s\n", file, b.fileHash(filepath.Join(p.Dir, file)))
371 }
372 for _, a1 := range a.Deps {
373 p1 := a1.Package
374 if p1 != nil && p1 != p {
375 fmt.Fprintf(h, "import %s %s\n", p1.ImportPath, buildExportID(a1.buildID))
376 }
377 if a1.Mode == "preprocess PGO profile" {
378 fmt.Fprintf(h, "pgofile %s\n", b.fileHash(a1.built))
379 }
380 }
381
382 return h.Sum()
383 }
384
385
386
387
388 func trimpathInvariant(p *load.Package) bool {
389 return p.Standard && p.Dir == filepath.Join(cfg.GOROOTsrc, p.Internal.OrigImportPath)
390 }
391
392
393
394 func (b *Builder) addPackageOrigin(h io.Writer, p *load.Package) {
395 if trimpathInvariant(p) {
396
397 } else if cfg.BuildTrimpath {
398 fmt.Fprintln(h, "trimpath")
399
400
401
402 if p.Module != nil {
403 fmt.Fprintf(h, "module %s@%s\n", p.Module.Path, p.Module.Version)
404 }
405 } else if p.Goroot {
406
407
408
409
410
411
412
413
414
415
416
417
418
419 } else if !strings.HasPrefix(p.Dir, b.WorkDir) {
420
421
422
423 fmt.Fprintf(h, "dir %s\n", p.Dir)
424 }
425 }
426
427
428
429 func (b *Builder) addCToolchainIDs(h io.Writer, p *load.Package) {
430 if len(p.CgoFiles)+len(p.SwigFiles)+len(p.SwigCXXFiles) > 0 {
431 fmt.Fprintf(h, "cgo %q\n", b.toolID("cgo"))
432 cppflags, cflags, cxxflags, fflags, ldflags, _ := b.CFlags(p)
433
434 ccExe := b.ccExe()
435 fmt.Fprintf(h, "CC=%q %q %q %q\n", ccExe, cppflags, cflags, ldflags)
436
437
438 if ccID, _, err := b.gccToolID(ccExe[0], "c"); err == nil {
439 fmt.Fprintf(h, "CC ID=%q\n", ccID)
440 } else {
441 fmt.Fprintf(h, "CC ID ERROR=%q\n", err)
442 }
443 if len(p.CXXFiles)+len(p.SwigCXXFiles) > 0 {
444 cxxExe := b.cxxExe()
445 fmt.Fprintf(h, "CXX=%q %q\n", cxxExe, cxxflags)
446 if cxxID, _, err := b.gccToolID(cxxExe[0], "c++"); err == nil {
447 fmt.Fprintf(h, "CXX ID=%q\n", cxxID)
448 } else {
449 fmt.Fprintf(h, "CXX ID ERROR=%q\n", err)
450 }
451 }
452 if len(p.FFiles) > 0 {
453 fcExe := b.fcExe()
454 fmt.Fprintf(h, "FC=%q %q\n", fcExe, fflags)
455 if fcID, _, err := b.gccToolID(fcExe[0], "f95"); err == nil {
456 fmt.Fprintf(h, "FC ID=%q\n", fcID)
457 } else {
458 fmt.Fprintf(h, "FC ID ERROR=%q\n", err)
459 }
460 }
461
462 }
463 }
464
465
466
467
468 func allowedVersion(v string) bool {
469
470 if v == "" {
471 return true
472 }
473 return gover.Compare(gover.Local(), v) >= 0
474 }
475
476 func (b *Builder) computeNonGoOverlay(a *Action, p *load.Package, sh *Shell, objdir string, nonGoFileLists [][]string) error {
477 OverlayLoop:
478 for _, fs := range nonGoFileLists {
479 for _, f := range fs {
480 if fsys.Replaced(mkAbs(p.Dir, f)) {
481 a.nonGoOverlay = make(map[string]string)
482 break OverlayLoop
483 }
484 }
485 }
486 if a.nonGoOverlay != nil {
487 for _, fs := range nonGoFileLists {
488 for i := range fs {
489 from := mkAbs(p.Dir, fs[i])
490 dst := objdir + filepath.Base(fs[i])
491 if err := sh.CopyFile(dst, fsys.Actual(from), 0666, false); err != nil {
492 return err
493 }
494 a.nonGoOverlay[from] = dst
495 }
496 }
497 }
498
499 return nil
500 }
501
502 func (b *Builder) runCover(ctx context.Context, a *Action) error {
503 p := a.Package
504 sh := b.Shell(a)
505
506
507 var covMetaFileName string
508 if a.Package.Internal.Cover.GenMeta {
509 covMetaFileName = a.Objdir + covcmd.MetaFileForPackage(a.Package.ImportPath)
510 }
511
512 if err := sh.Mkdir(a.Objdir); err != nil {
513 return err
514 }
515
516 a.actionID = b.coverActionID(a, covMetaFileName)
517 if pr, err := b.loadCachedCoverOutputs(a); err == nil {
518 a.Provider = pr
519 return nil
520 }
521
522 gofiles := slices.Clone(a.Package.GoFiles)
523 cgofiles := slices.Clone(a.Package.CgoFiles)
524
525 outfiles := []string{}
526 infiles := []string{}
527 for i, file := range slices.Concat(gofiles, cgofiles) {
528 if base.IsTestFile(file) {
529 continue
530 }
531
532 var sourceFile string
533 var coverFile string
534 if base, found := strings.CutSuffix(file, ".cgo1.go"); found {
535
536 base = filepath.Base(base)
537 sourceFile = file
538 coverFile = a.Objdir + base + ".cgo1.go"
539 } else {
540 sourceFile = filepath.Join(p.Dir, file)
541 coverFile = a.Objdir + file
542 }
543 coverFile = strings.TrimSuffix(coverFile, ".go") + ".cover.go"
544 infiles = append(infiles, sourceFile)
545 outfiles = append(outfiles, coverFile)
546 if i < len(gofiles) {
547 gofiles[i] = coverFile
548 } else {
549 cgofiles[i-len(gofiles)] = coverFile
550 }
551 }
552
553 var coverCfg string
554 if len(infiles) != 0 {
555
556
557
558
559
560
561
562
563
564 sum := sha256.Sum256([]byte(a.Package.ImportPath))
565 coverVar := fmt.Sprintf("goCover_%x_", sum[:6])
566 mode := a.Package.Internal.Cover.Mode
567 if mode == "" {
568 panic("covermode should be set at this point")
569 }
570 coverCfg = a.Objdir + "coveragecfg"
571 if newoutfiles, err := b.cover(a, infiles, outfiles, coverVar, mode, covMetaFileName, coverCfg); err != nil {
572 return err
573 } else {
574 outfiles = newoutfiles
575 gofiles = append([]string{newoutfiles[0]}, gofiles...)
576 }
577 }
578
579 pr := &coverProvider{covMetaFileName, coverCfg, gofiles, cgofiles}
580 a.Provider = pr
581
582 if !cfg.BuildN {
583 if err := b.cacheCoverOutputs(a, pr); err != nil {
584 return err
585 }
586 }
587
588 return nil
589 }
590
591
592
593 func (b *Builder) buildExport(ctx context.Context, a *Action) (err error) {
594 p := a.Package
595 sh := b.Shell(a)
596
597 bit := func(x uint32, b bool) uint32 {
598 if b {
599 return x
600 }
601 return 0
602 }
603
604 const (
605 needBuild uint32 = 1 << iota
606 needVet
607 needCompiledGoFiles
608 )
609
610 cachedBuild := false
611 need := bit(needBuild, !b.IsCmdList && a.needBuild || b.NeedExport) |
612 bit(needVet, a.needVet) |
613 bit(needCompiledGoFiles, b.NeedCompiledGoFiles)
614
615 actionID := b.buildActionID(a)
616 if b.useCache(a, actionID, p.Target, need&needBuild != 0) {
617
618
619
620
621
622 cachedBuild = true
623 a.output = []byte{}
624 need &^= needBuild
625 if b.NeedExport {
626 p.Export = a.built
627 p.BuildID = a.buildID
628 }
629 if need&needCompiledGoFiles != 0 {
630 if err := b.loadCachedCompiledGoFiles(a); err == nil {
631 need &^= needCompiledGoFiles
632 }
633 }
634 }
635
636
637
638 if !cachedBuild && need&needCompiledGoFiles != 0 {
639 if err := b.loadCachedCompiledGoFiles(a); err == nil {
640 need &^= needCompiledGoFiles
641 }
642 }
643
644 if need == 0 {
645 return nil
646 }
647 defer b.flushOutput(a)
648
649 defer func() {
650 if err != nil && b.IsCmdList && b.NeedError && p.Error == nil {
651 p.Error = &load.PackageError{Err: err}
652 }
653 }()
654
655 if p.Error != nil {
656
657
658 return p.Error
659 }
660
661 if p.Module != nil && !allowedVersion(p.Module.GoVersion) {
662 return errors.New("module requires Go " + p.Module.GoVersion + " or later")
663 }
664
665 if err := b.checkDirectives(a); err != nil {
666 return err
667 }
668
669 if err := sh.Mkdir(a.Objdir); err != nil {
670 return err
671 }
672
673
674
675
676
677 if need == needVet {
678 if err := b.loadCachedVet(a, a.Deps); err == nil {
679 need &^= needVet
680 }
681 }
682
683 var coverPr *coverProvider
684 var runCgoPr *runCgoProvider
685 for _, dep := range a.Deps {
686 switch pr := dep.Provider.(type) {
687 case *coverProvider:
688 coverPr = pr
689 case *runCgoProvider:
690 runCgoPr = pr
691 }
692 }
693
694 if need == 0 {
695 return
696 }
697 defer b.flushOutput(a)
698
699 if cfg.BuildN {
700
701
702
703
704
705 sh.Printf("\n#\n# %s\n#\n\n", p.ImportPath)
706 }
707
708 if cfg.BuildV {
709 sh.Printf("%s\n", p.ImportPath)
710 }
711
712 objdir := a.Objdir
713
714 if err := AllowInstall(a); err != nil {
715 return err
716 }
717
718
719 dir, _ := filepath.Split(a.Target)
720 if dir != "" {
721 if err := sh.Mkdir(dir); err != nil {
722 return err
723 }
724 }
725
726 gofiles := p.GoFiles
727 cfiles := p.CFiles
728 sfiles := p.SFiles
729 var objects, cgoObjects []string
730
731
732 if p.Internal.Cover.Mode != "" {
733 gofiles = coverPr.goSources
734 }
735 gofiles = slices.Clip(gofiles)
736
737 if p.UsesCgo() || p.UsesSwig() {
738 if runCgoPr == nil {
739 base.Fatalf("internal error: could not find runCgoProvider")
740 }
741
742
743
744
745
746 cfiles = nil
747 if p.Standard && p.ImportPath == "runtime/cgo" {
748
749 sfiles = slices.Clone(sfiles)
750 sfiles = slices.DeleteFunc(sfiles, func(f string) bool {
751 return strings.HasPrefix(f, "gcc_")
752 })
753 } else {
754 sfiles = nil
755 }
756 outGo, outObj, err := b.processCgoOutputs(a, runCgoPr, base.Tool("cgo"), objdir)
757
758 if err != nil {
759 return err
760 }
761 if cfg.BuildToolchainName == "gccgo" {
762 cgoObjects = append(cgoObjects, a.Objdir+"_cgo_flags")
763 }
764 cgoObjects = append(cgoObjects, outObj...)
765 gofiles = append(gofiles, outGo...)
766 }
767
768 var srcfiles []string
769 srcfiles = append(srcfiles, gofiles...)
770 srcfiles = append(srcfiles, sfiles...)
771 srcfiles = append(srcfiles, cfiles...)
772 b.cacheSrcFiles(a, srcfiles)
773
774
775 if len(gofiles) == 0 {
776 return &load.NoGoError{Package: p}
777 }
778
779
780 if need&needVet != 0 {
781 buildVetConfig(a, srcfiles, a.Deps)
782 need &^= needVet
783 }
784 if need&needCompiledGoFiles != 0 {
785 if err := b.loadCachedCompiledGoFiles(a); err != nil {
786 return fmt.Errorf("loading compiled Go files from cache: %w", err)
787 }
788 need &^= needCompiledGoFiles
789 }
790 if need == 0 {
791
792 return nil
793 }
794
795
796 symabis, err := BuildToolchain.symabis(b, a, sfiles)
797 if err != nil {
798 return err
799 }
800
801
802
803
804
805
806
807 var icfg bytes.Buffer
808 fmt.Fprintf(&icfg, "# import config\n")
809 for i, raw := range p.Internal.RawImports {
810 final := p.Imports[i]
811 if final != raw {
812 fmt.Fprintf(&icfg, "importmap %s=%s\n", raw, final)
813 }
814 }
815 for _, a1 := range a.Deps {
816 p1 := a1.Package
817 if p1 == nil || p1.ImportPath == "" || a1.built == "" {
818 continue
819 }
820 fmt.Fprintf(&icfg, "packagefile %s=%s\n", p1.ImportPath, a1.built)
821 }
822
823
824
825 var embedcfg []byte
826 if len(p.Internal.Embed) > 0 {
827 var embed struct {
828 Patterns map[string][]string
829 Files map[string]string
830 }
831 embed.Patterns = p.Internal.Embed
832 embed.Files = make(map[string]string)
833 for _, file := range p.EmbedFiles {
834 embed.Files[file] = fsys.Actual(filepath.Join(p.Dir, file))
835 }
836 js, err := json.Marshal(&embed)
837 if err != nil {
838 return fmt.Errorf("marshal embedcfg: %v", err)
839 }
840 embedcfg = js
841 }
842
843
844 var pgoProfile string
845 for _, a1 := range a.Deps {
846 if a1.Mode != "preprocess PGO profile" {
847 continue
848 }
849 if pgoProfile != "" {
850 return fmt.Errorf("action contains multiple PGO profile dependencies")
851 }
852 pgoProfile = a1.built
853 }
854
855 var coverageConfig string
856 if coverPr != nil {
857 coverageConfig = coverPr.coverageConfig
858 }
859
860 if p.Internal.BuildInfo != nil && cfg.ModulesEnabled {
861 prog := modload.ModInfoProg(p.Internal.BuildInfo.String(), cfg.BuildToolchainName == "gccgo")
862 if len(prog) > 0 {
863 if err := sh.writeFile(objdir+"_gomod_.go", prog); err != nil {
864 return err
865 }
866 gofiles = append(gofiles, objdir+"_gomod_.go")
867 }
868 }
869
870
871
872
873 exportFile := objdir + "_pkg_.a"
874 if cfg.BuildToolchainName == "gc" {
875 exportFile = filepath.Join(b.WorkDir, "export", filepath.Base(filepath.Clean(objdir))+".a")
876 if err := sh.Mkdir(filepath.Dir(exportFile)); err != nil {
877 return err
878 }
879 }
880 ofile, out, compile, err := BuildToolchain.gc(b, a, exportFile, icfg.Bytes(), embedcfg, symabis, len(sfiles) > 0, pgoProfile, coverageConfig, gofiles)
881 if err := b.reportCompile(a, out, err); err != nil {
882 return err
883 }
884 if ofile != exportFile {
885 objects = append(objects, ofile)
886 }
887
888 a.built = exportFile
889 if cfg.BuildToolchainName == "gc" {
890 if err := b.updateExportBuildID(a, exportFile); err != nil {
891 if compile != nil {
892 _, werr := compile.wait()
893 err = errors.Join(err, werr)
894 }
895 return err
896 }
897 }
898
899 ep := &exportProvider{
900 exportFile: exportFile,
901 objects: objects,
902 cgoObjects: cgoObjects,
903 cfiles: cfiles,
904 sfiles: sfiles,
905 output: a.output,
906 compile: compile,
907 }
908 a.output = nil
909 a.Provider = ep
910 return nil
911 }
912
913 func (b *Builder) buildObject(ctx context.Context, a *Action) error {
914 p := a.Package
915 sh := b.Shell(a)
916
917 exportAction := a.Deps[0]
918 a.actionID = exportAction.actionID
919 a.buildID = exportAction.buildID
920
921 ep, _ := exportAction.Provider.(*exportProvider)
922 if a.Failed != nil {
923 if ep != nil && ep.compile != nil {
924 _, err := ep.compile.wait()
925 return err
926 }
927 return nil
928 }
929 if ep == nil {
930 a.built = exportAction.built
931 if b.NeedExport {
932 p.Export = a.built
933 p.BuildID = a.buildID
934 }
935 return nil
936 }
937
938 a.output = ep.output
939 defer b.flushOutput(a)
940
941 if ep.compile != nil {
942 out, err := ep.compile.wait()
943 if err := b.reportCompile(a, out, err); err != nil {
944 return err
945 }
946 }
947
948 if b.IsCmdList && !b.NeedExport {
949 return nil
950 }
951 if p.Error != nil {
952 return p.Error
953 }
954
955 if err := sh.Mkdir(a.Objdir); err != nil {
956 return err
957 }
958
959 objdir := a.Objdir
960 objpkg := objdir + "_pkg_.a"
961 objects := ep.objects
962
963 cfiles := ep.cfiles
964 sfiles := ep.sfiles
965
966
967
968
969 _goos_goarch := "_" + cfg.Goos + "_" + cfg.Goarch
970 _goos := "_" + cfg.Goos
971 _goarch := "_" + cfg.Goarch
972 for _, file := range p.HFiles {
973 name, ext := fileExtSplit(file)
974 switch {
975 case strings.HasSuffix(name, _goos_goarch):
976 targ := file[:len(name)-len(_goos_goarch)] + "_GOOS_GOARCH." + ext
977 if err := sh.CopyFile(objdir+targ, filepath.Join(p.Dir, file), 0666, true); err != nil {
978 return err
979 }
980 case strings.HasSuffix(name, _goarch):
981 targ := file[:len(name)-len(_goarch)] + "_GOARCH." + ext
982 if err := sh.CopyFile(objdir+targ, filepath.Join(p.Dir, file), 0666, true); err != nil {
983 return err
984 }
985 case strings.HasSuffix(name, _goos):
986 targ := file[:len(name)-len(_goos)] + "_GOOS." + ext
987 if err := sh.CopyFile(objdir+targ, filepath.Join(p.Dir, file), 0666, true); err != nil {
988 return err
989 }
990 }
991 }
992
993 if err := b.computeNonGoOverlay(a, p, sh, objdir, [][]string{cfiles}); err != nil {
994 return err
995 }
996
997
998
999 for _, file := range cfiles {
1000 out := file[:len(file)-len(".c")] + ".o"
1001 if err := BuildToolchain.cc(b, a, objdir+out, file); err != nil {
1002 return err
1003 }
1004 objects = append(objects, out)
1005 }
1006
1007
1008 if len(sfiles) > 0 {
1009 ofiles, err := BuildToolchain.asm(b, a, sfiles)
1010 if err != nil {
1011 return err
1012 }
1013 objects = append(objects, ofiles...)
1014 }
1015
1016
1017
1018
1019 if a.buildID != "" && cfg.BuildToolchainName == "gccgo" {
1020 switch cfg.Goos {
1021 case "aix", "android", "dragonfly", "freebsd", "illumos", "linux", "netbsd", "openbsd", "solaris":
1022 asmfile, err := b.gccgoBuildIDFile(a)
1023 if err != nil {
1024 return err
1025 }
1026 ofiles, err := BuildToolchain.asm(b, a, []string{asmfile})
1027 if err != nil {
1028 return err
1029 }
1030 objects = append(objects, ofiles...)
1031 }
1032 }
1033
1034
1035
1036
1037
1038 objects = append(objects, ep.cgoObjects...)
1039
1040
1041 for _, syso := range p.SysoFiles {
1042 sysoPath := filepath.Join(p.Dir, syso)
1043 if !cfg.BuildN {
1044 if err := checkLinkerInputFile(".syso", sysoPath); err != nil {
1045 return err
1046 }
1047 }
1048 objects = append(objects, sysoPath)
1049 }
1050
1051
1052
1053
1054
1055
1056 if ep.exportFile != objpkg {
1057 if err := sh.CopyFile(objpkg, ep.exportFile, 0666, true); err != nil {
1058 return err
1059 }
1060 }
1061 if len(objects) > 0 {
1062 if err := BuildToolchain.pack(b, a, objpkg, objects); err != nil {
1063 return err
1064 }
1065 }
1066
1067 if err := b.updateBuildID(a, objpkg); err != nil {
1068 return err
1069 }
1070
1071 a.built = objpkg
1072 return nil
1073 }
1074
1075 func (b *Builder) reportCompile(a *Action, out []byte, err error) error {
1076 p := a.Package
1077 if len(out) > 0 && (p.UsesCgo() || p.UsesSwig()) && !cfg.BuildX {
1078
1079
1080
1081 out = cgoTypeSigRe.ReplaceAll(out, []byte("C."))
1082 }
1083 return b.Shell(a).reportCmd("", "", out, err)
1084 }
1085
1086 var cgoTypeSigRe = lazyregexp.New(`\b_C2?(type|func|var|macro)_\B`)
1087
1088 func (b *Builder) checkDirectives(a *Action) error {
1089 var msg []byte
1090 p := a.Package
1091 var seen map[string]token.Position
1092 for _, d := range p.Internal.Build.Directives {
1093 if strings.HasPrefix(d.Text, "//go:debug") {
1094 key, _, err := load.ParseGoDebug(d.Text)
1095 if err != nil && err != load.ErrNotGoDebug {
1096 msg = fmt.Appendf(msg, "%s: invalid //go:debug: %v\n", d.Pos, err)
1097 continue
1098 }
1099 if pos, ok := seen[key]; ok {
1100 msg = fmt.Appendf(msg, "%s: repeated //go:debug for %v\n\t%s: previous //go:debug\n", d.Pos, key, pos)
1101 continue
1102 }
1103 if seen == nil {
1104 seen = make(map[string]token.Position)
1105 }
1106 seen[key] = d.Pos
1107 }
1108 }
1109 if len(msg) > 0 {
1110
1111
1112
1113 err := errors.New("invalid directive")
1114 return b.Shell(a).reportCmd("", "", msg, err)
1115 }
1116 return nil
1117 }
1118
1119 func (b *Builder) cacheObjdirFile(a *Action, c cache.Cache, name string) error {
1120 f, err := os.Open(a.Objdir + name)
1121 if err != nil {
1122 return err
1123 }
1124 defer f.Close()
1125 _, _, err = c.Put(cache.Subkey(a.actionID, name), f)
1126 return err
1127 }
1128
1129 func (b *Builder) findCachedObjdirFile(a *Action, c cache.Cache, name string) (string, error) {
1130 file, _, err := cache.GetFile(c, cache.Subkey(a.actionID, name))
1131 if err != nil {
1132 return "", fmt.Errorf("loading cached file %s: %w", name, err)
1133 }
1134 return file, nil
1135 }
1136
1137 func (b *Builder) loadCachedObjdirFile(a *Action, c cache.Cache, name string) error {
1138 cached, err := b.findCachedObjdirFile(a, c, name)
1139 if err != nil {
1140 return err
1141 }
1142 return b.Shell(a).CopyFile(a.Objdir+name, cached, 0666, true)
1143 }
1144
1145 func (b *Builder) cacheSrcFiles(a *Action, srcfiles []string) {
1146 c := cache.Default()
1147 var buf bytes.Buffer
1148 for _, file := range srcfiles {
1149 if !strings.HasPrefix(file, a.Objdir) {
1150
1151 buf.WriteString("./")
1152 buf.WriteString(file)
1153 buf.WriteString("\n")
1154 continue
1155 }
1156 name := file[len(a.Objdir):]
1157 buf.WriteString(name)
1158 buf.WriteString("\n")
1159 if err := b.cacheObjdirFile(a, c, name); err != nil {
1160 return
1161 }
1162 }
1163 cache.PutBytes(c, cache.Subkey(a.actionID, "srcfiles"), buf.Bytes())
1164 }
1165
1166
1167
1168
1169
1170 type coverProviderCached struct {
1171 CovMetaFile string
1172 CoverageConfig string
1173 GoSources, CgoSources []string
1174 }
1175
1176 func (b *Builder) cacheCoverOutputs(a *Action, pr *coverProvider) error {
1177 c := cache.Default()
1178
1179 cacheSrcFileName := func(a *Action, file string) string {
1180 if name, ok := strings.CutPrefix(file, a.Objdir); ok {
1181 return name
1182 }
1183 return "./" + file
1184 }
1185
1186 b.cacheSrcFiles(a, slices.Concat(pr.goSources, pr.cgoSources))
1187 var cached coverProviderCached
1188 if pr.covMetaFileName != "" {
1189 cached.CovMetaFile = strings.TrimPrefix(pr.covMetaFileName, a.Objdir)
1190 if err := b.cacheObjdirFile(a, c, cached.CovMetaFile); err != nil {
1191 return err
1192 }
1193 }
1194 if pr.coverageConfig != "" {
1195 cached.CoverageConfig = strings.TrimPrefix(pr.coverageConfig, a.Objdir)
1196 if err := b.cacheObjdirFile(a, c, cached.CoverageConfig); err != nil {
1197 return err
1198 }
1199 }
1200
1201 for _, fn := range pr.goSources {
1202 cached.GoSources = append(cached.GoSources, cacheSrcFileName(a, fn))
1203 }
1204 for _, fn := range pr.cgoSources {
1205 cached.CgoSources = append(cached.CgoSources, cacheSrcFileName(a, fn))
1206 }
1207 js, err := json.Marshal(cached)
1208 if err != nil {
1209 return err
1210 }
1211 cache.PutBytes(c, cache.Subkey(a.actionID, "coverprovider"), js)
1212
1213 return nil
1214 }
1215
1216 func (b *Builder) loadCachedCoverOutputs(a *Action) (*coverProvider, error) {
1217 c := cache.Default()
1218
1219 if _, err := b.loadCachedSrcFiles(a); err != nil {
1220 return nil, err
1221 }
1222
1223 var cached coverProviderCached
1224 if js, _, err := cache.GetBytes(c, cache.Subkey(a.actionID, "coverprovider")); err != nil {
1225 return nil, err
1226 } else if err := json.Unmarshal(js, &cached); err != nil {
1227 return nil, err
1228 }
1229
1230 covMetaFile := cached.CovMetaFile
1231 if covMetaFile != "" {
1232 if err := b.loadCachedObjdirFile(a, c, covMetaFile); err != nil {
1233 return nil, err
1234 }
1235 covMetaFile = a.Objdir + covMetaFile
1236 }
1237 coverageConfig := cached.CoverageConfig
1238 if coverageConfig != "" {
1239 if err := b.loadCachedObjdirFile(a, c, coverageConfig); err != nil {
1240 return nil, err
1241 }
1242 coverageConfig = a.Objdir + coverageConfig
1243 }
1244
1245 var goSources, cgoSources []string
1246 for _, file := range cached.GoSources {
1247 name, ok := strings.CutPrefix(file, "./")
1248 if !ok {
1249 name = a.Objdir + name
1250 }
1251 goSources = append(goSources, name)
1252 }
1253 for _, file := range cached.CgoSources {
1254 name, ok := strings.CutPrefix(file, "./")
1255 if !ok {
1256 name = a.Objdir + name
1257 }
1258 cgoSources = append(cgoSources, name)
1259 }
1260
1261 pr := &coverProvider{
1262 covMetaFileName: covMetaFile,
1263 coverageConfig: coverageConfig,
1264 goSources: goSources,
1265 cgoSources: cgoSources,
1266 }
1267
1268 return pr, nil
1269 }
1270
1271 func (b *Builder) coverActionID(a *Action, covMetaFileName string) cache.ActionID {
1272 p := a.Package
1273 h := cache.NewHash("cover " + p.ImportPath)
1274 fmt.Fprintf(h, "cover %q\n", b.toolID("cover"))
1275 b.addPackageOrigin(h, p)
1276
1277
1278 fmt.Fprintf(h, "setup %s %v\n", p.Internal.Cover.Mode, p.Internal.Cover.GenMeta)
1279 fmt.Fprintf(h, "config ")
1280 if err := json.NewEncoder(h).Encode(coverConfig(p, filepath.Base(covMetaFileName), "")); err != nil {
1281 base.Fatal(err)
1282 }
1283 for _, file := range slices.Concat(p.GoFiles, p.CgoFiles) {
1284 fmt.Fprintf(h, "file %s %s\n", file, b.fileHash(filepath.Join(p.Dir, file)))
1285 }
1286
1287 return h.Sum()
1288 }
1289
1290
1291
1292 func (b *Builder) cgoCompileActionID(a *Action, f string, flags []string) cache.ActionID {
1293 h := cache.NewHash("cgo compile file")
1294 p := a.Package
1295
1296 fmt.Fprintf(h, "goos %s goarch %s\n", cfg.Goos, cfg.Goarch)
1297
1298 fmt.Fprintf(h, "file %s %s\n", filepath.Base(f), b.fileHash(f))
1299 fmt.Fprintf(h, "flags %q\n", replaceAll(flags, a.Objdir, "$OBJDIR/"))
1300
1301
1302
1303
1304 b.addPackageOrigin(h, p)
1305
1306
1307
1308
1309
1310
1311 b.addCToolchainIDs(h, p)
1312
1313 return h.Sum()
1314 }
1315
1316
1317
1318 func (b *Builder) cgoRunActionID(a *Action) cache.ActionID {
1319 p := a.Package
1320 h := cache.NewHash("cgo " + p.ImportPath)
1321
1322 fmt.Fprintf(h, "goos %s goarch %s\n", cfg.Goos, cfg.Goarch)
1323
1324 fmt.Fprintf(h, "cgo %q\n", b.toolID("cgo"))
1325
1326
1327
1328
1329
1330 fmt.Fprintf(h, "import %q\n", p.ImportPath)
1331
1332
1333
1334
1335 fmt.Fprintf(h, "dir %s\n", p.Dir)
1336 b.addCToolchainIDs(h, p)
1337
1338
1339 fmt.Fprintf(h, "msan %v asan %v\n", cfg.BuildMSan, cfg.BuildASan)
1340
1341 fmt.Fprintf(h, "exportheader %v\n", cfg.BuildBuildmode == "c-archive" || cfg.BuildBuildmode == "c-shared")
1342
1343 if cfg.BuildToolchainName == "gccgo" {
1344 fmt.Fprintf(h, "gccgopkgpath %s\n", gccgoPkgpath(p))
1345 }
1346
1347
1348 fmt.Fprintf(h, "mfiles %v cxxfiles %v ffiles %v\n", len(p.MFiles) > 0, len(p.CXXFiles)+len(p.SwigCXXFiles) > 0, len(p.FFiles) > 0)
1349
1350
1351 if p.Internal.Cover.Mode != "" {
1352
1353 for _, dep := range a.Deps {
1354 if dep.Mode == "cover" {
1355 fmt.Fprintf(h, "cover %x\n", dep.actionID)
1356 break
1357 }
1358 }
1359 } else {
1360 for _, file := range p.CgoFiles {
1361 fmt.Fprintf(h, "file %s %s\n", file, b.fileHash(filepath.Join(p.Dir, file)))
1362 }
1363 }
1364 for _, file := range slices.Concat(p.SwigFiles, p.SwigCXXFiles) {
1365 fmt.Fprintf(h, "file %s %s\n", file, b.fileHash(filepath.Join(p.Dir, file)))
1366 }
1367
1368 return h.Sum()
1369 }
1370
1371
1372
1373 type runCgoProviderCached struct {
1374 CFLAGS, CXXFLAGS, FFLAGS, LDFLAGS []string
1375 NotCompatibleForInternalLinking bool
1376 GoFiles []string
1377 Files []string
1378 }
1379
1380 func replaceAll(strs []string, from, to string) []string {
1381 var replaced []string
1382 for _, s := range strs {
1383 replaced = append(replaced, strings.ReplaceAll(s, from, to))
1384 }
1385 return replaced
1386 }
1387
1388 func (b *Builder) cacheRunCgoOutputs(a *Action, pr *runCgoProvider) error {
1389 c := cache.Default()
1390
1391
1392 trimObjdirPrefix := func(files []string) []string {
1393 var trimmed []string
1394 for _, f := range files {
1395 trimmed = append(trimmed, strings.TrimPrefix(f, a.Objdir))
1396 }
1397 return trimmed
1398 }
1399
1400 cgo2Files := func(cgo1Files []string) []string {
1401 var cgo2 []string
1402 for _, f := range cgo1Files {
1403 if base, ok := strings.CutSuffix(f, ".cgo1.go"); ok {
1404 cgo2 = append(cgo2, base+".cgo2.c")
1405 }
1406 }
1407 return cgo2
1408 }
1409
1410 _, outC, outCXX := b.swigOutputs(a.Package, a.Objdir)
1411 files := slices.Concat(
1412 []string{"_cgo_export.c", "_cgo_export.h", "_cgo_main.c"},
1413 trimObjdirPrefix(pr.goFiles),
1414 trimObjdirPrefix(cgo2Files(pr.goFiles)),
1415 trimObjdirPrefix(outC),
1416 trimObjdirPrefix(outCXX))
1417 for _, name := range []string{"_cgo_install.h", "_cgo_defun.c", "_cgo_flags"} {
1418 if _, err := os.Stat(a.Objdir + name); err == nil {
1419 files = append(files, name)
1420 }
1421 }
1422 for _, file := range files {
1423 if err := b.cacheObjdirFile(a, c, file); err != nil {
1424 return err
1425 }
1426 }
1427
1428 cached := runCgoProviderCached{
1429 CFLAGS: replaceAll(pr.CFLAGS, a.Objdir, "$OBJDIR/"),
1430 CXXFLAGS: replaceAll(pr.CXXFLAGS, a.Objdir, "$OBJDIR/"),
1431 FFLAGS: replaceAll(pr.FFLAGS, a.Objdir, "$OBJDIR/"),
1432 LDFLAGS: replaceAll(pr.LDFLAGS, a.Objdir, "$OBJDIR/"),
1433 NotCompatibleForInternalLinking: pr.notCompatibleForInternalLinking,
1434 GoFiles: trimObjdirPrefix(pr.goFiles),
1435 Files: files,
1436 }
1437 data, err := json.Marshal(cached)
1438 if err != nil {
1439 return err
1440 }
1441 cache.PutBytes(c, cache.Subkey(a.actionID, "cgorunprovider"), data)
1442 return nil
1443 }
1444
1445 func (b *Builder) loadCachedRunCgoOutputs(a *Action) (*runCgoProvider, error) {
1446 c := cache.Default()
1447
1448 var cached runCgoProviderCached
1449 js, _, err := cache.GetBytes(c, cache.Subkey(a.actionID, "cgorunprovider"))
1450 if err != nil {
1451 return nil, err
1452 } else if err := json.Unmarshal(js, &cached); err != nil {
1453 return nil, err
1454 }
1455
1456 for _, name := range cached.Files {
1457 if err := b.loadCachedObjdirFile(a, c, name); err != nil {
1458 return nil, err
1459 }
1460 }
1461
1462 var goFilesObjdir []string
1463 for _, f := range cached.GoFiles {
1464 goFilesObjdir = append(goFilesObjdir, a.Objdir+f)
1465 }
1466
1467 pr := &runCgoProvider{
1468 CFLAGS: replaceAll(cached.CFLAGS, "$OBJDIR/", a.Objdir),
1469 CXXFLAGS: replaceAll(cached.CXXFLAGS, "$OBJDIR/", a.Objdir),
1470 FFLAGS: replaceAll(cached.FFLAGS, "$OBJDIR/", a.Objdir),
1471 LDFLAGS: replaceAll(cached.LDFLAGS, "$OBJDIR/", a.Objdir),
1472 notCompatibleForInternalLinking: cached.NotCompatibleForInternalLinking,
1473 goFiles: goFilesObjdir,
1474 }
1475
1476 return pr, nil
1477 }
1478
1479 func (b *Builder) loadCachedSrcFiles(a *Action) ([]string, error) {
1480 c := cache.Default()
1481 list, _, err := cache.GetBytes(c, cache.Subkey(a.actionID, "srcfiles"))
1482 if err != nil {
1483 return nil, fmt.Errorf("reading srcfiles list: %w", err)
1484 }
1485 var srcfiles []string
1486 for name := range strings.SplitSeq(string(list), "\n") {
1487 if name == "" {
1488 continue
1489 }
1490 if strings.HasPrefix(name, "./") {
1491 srcfiles = append(srcfiles, name[2:])
1492 continue
1493 }
1494 if err := b.loadCachedObjdirFile(a, c, name); err != nil {
1495 return nil, err
1496 }
1497 srcfiles = append(srcfiles, a.Objdir+name)
1498 }
1499 return srcfiles, nil
1500 }
1501
1502 func (b *Builder) loadCachedVet(a *Action, vetDeps []*Action) error {
1503 srcfiles, err := b.loadCachedSrcFiles(a)
1504 if err != nil {
1505 return err
1506 }
1507 buildVetConfig(a, srcfiles, vetDeps)
1508 return nil
1509 }
1510
1511 func (b *Builder) loadCachedCompiledGoFiles(a *Action) error {
1512 c := cache.Default()
1513 list, _, err := cache.GetBytes(c, cache.Subkey(a.actionID, "srcfiles"))
1514 if err != nil {
1515 return fmt.Errorf("reading srcfiles list: %w", err)
1516 }
1517 var gofiles []string
1518 for name := range strings.SplitSeq(string(list), "\n") {
1519 if name == "" {
1520 continue
1521 } else if !strings.HasSuffix(name, ".go") {
1522 continue
1523 }
1524 if strings.HasPrefix(name, "./") {
1525 gofiles = append(gofiles, name[len("./"):])
1526 continue
1527 }
1528 file, err := b.findCachedObjdirFile(a, c, name)
1529 if err != nil {
1530 return fmt.Errorf("finding %s: %w", name, err)
1531 }
1532 gofiles = append(gofiles, file)
1533 }
1534 a.Package.CompiledGoFiles = gofiles
1535 return nil
1536 }
1537
1538
1539 type vetConfig struct {
1540 ID string
1541 Compiler string
1542 Dir string
1543 ImportPath string
1544 GoFiles []string
1545 NonGoFiles []string
1546 IgnoredFiles []string
1547
1548 Module *vetModule
1549 ImportMap map[string]string
1550 PackageFile map[string]string
1551 Standard map[string]bool
1552 PackageVetx map[string]string
1553 VetxOnly bool
1554 VetxOutput string
1555 Stdout string
1556 GoVersion string
1557 FixArchive string
1558
1559 SucceedOnTypecheckFailure bool
1560 }
1561
1562
1563 type exportConfig struct {
1564 ImportPath string
1565 GoVersion string
1566 GoFiles []string
1567 ImportMap map[string]string
1568 PackageFile map[string]string
1569 Output string
1570 TrimPath string
1571 }
1572
1573
1574
1575
1576
1577
1578 type vetModule struct {
1579 Path string
1580 Version string
1581 Replace *vetModule
1582 Time *time.Time
1583 Main bool
1584 Indirect bool
1585 Dir string
1586 GoMod string
1587 GoVersion string
1588 Error *vetModuleError
1589 }
1590
1591
1592 type vetModuleError struct {
1593 Err string
1594 }
1595
1596
1597 func analysisModuleFromModulePublic(m *modinfo.ModulePublic) *vetModule {
1598 if m == nil {
1599 return nil
1600 }
1601 vm := &vetModule{
1602 Path: m.Path,
1603 Version: m.Version,
1604 Replace: analysisModuleFromModulePublic(m.Replace),
1605 Time: m.Time,
1606 Main: m.Main,
1607 Indirect: m.Indirect,
1608 Dir: m.Dir,
1609 GoMod: m.GoMod,
1610 GoVersion: m.GoVersion,
1611 }
1612 if m.Error != nil {
1613 vm.Error = &vetModuleError{Err: m.Error.Err}
1614 }
1615 return vm
1616 }
1617
1618 func buildVetConfig(a *Action, srcfiles []string, vetDeps []*Action) {
1619
1620
1621 var gofiles, nongofiles []string
1622 for _, name := range srcfiles {
1623 if strings.HasSuffix(name, ".go") {
1624 gofiles = append(gofiles, name)
1625 } else {
1626 nongofiles = append(nongofiles, name)
1627 }
1628 }
1629
1630 ignored := slices.Concat(a.Package.IgnoredGoFiles, a.Package.IgnoredOtherFiles)
1631
1632
1633
1634
1635
1636
1637 vcfg := &vetConfig{
1638 ID: a.Package.ImportPath,
1639 Compiler: cfg.BuildToolchainName,
1640 Dir: a.Package.Dir,
1641 GoFiles: trimObjdir(a, actualFiles(mkAbsFiles(a.Package.Dir, gofiles))),
1642 NonGoFiles: trimObjdir(a, actualFiles(mkAbsFiles(a.Package.Dir, nongofiles))),
1643 IgnoredFiles: trimObjdir(a, actualFiles(mkAbsFiles(a.Package.Dir, ignored))),
1644 ImportPath: a.Package.ImportPath,
1645 ImportMap: make(map[string]string),
1646 PackageFile: make(map[string]string),
1647 Standard: make(map[string]bool),
1648 }
1649 v := gover.Local()
1650 if a.Package.Module != nil {
1651 v = cmp.Or(a.Package.Module.GoVersion, gover.DefaultGoModVersion)
1652 vcfg.Module = analysisModuleFromModulePublic(a.Package.Module)
1653 }
1654 vcfg.GoVersion = "go" + v
1655
1656 a.vetCfg = vcfg
1657 for i, raw := range a.Package.Internal.RawImports {
1658 final := a.Package.Imports[i]
1659 vcfg.ImportMap[raw] = final
1660 }
1661
1662
1663
1664 vcfgMapped := make(map[string]bool)
1665 for _, p := range vcfg.ImportMap {
1666 vcfgMapped[p] = true
1667 }
1668
1669 for _, a1 := range vetDeps {
1670 p1 := a1.Package
1671 if p1 == nil || p1.ImportPath == "" || p1 == a.Package {
1672 continue
1673 }
1674
1675
1676 if !vcfgMapped[p1.ImportPath] {
1677 vcfg.ImportMap[p1.ImportPath] = p1.ImportPath
1678 }
1679 if a1.built != "" {
1680 vcfg.PackageFile[p1.ImportPath] = a1.built
1681 }
1682 if p1.Standard {
1683 vcfg.Standard[p1.ImportPath] = true
1684 }
1685 }
1686 }
1687
1688
1689
1690
1691 var VetTool string
1692
1693
1694
1695 var VetFlags []string
1696
1697
1698
1699
1700 var VetHandleStdout = copyToStdout
1701
1702
1703
1704 var VetExplicit bool
1705
1706 func (b *Builder) vet(ctx context.Context, a *Action) error {
1707
1708
1709 a.Failed = nil
1710
1711 if a.Deps[0].Failed != nil {
1712
1713
1714
1715 return nil
1716 }
1717
1718 vcfg := a.Deps[0].vetCfg
1719 if vcfg == nil {
1720
1721 return fmt.Errorf("vet config not found")
1722 }
1723
1724 sh := b.Shell(a)
1725
1726
1727 vcfg.VetxOnly = a.VetxOnly
1728 vcfg.VetxOutput = a.Objdir + "vet.out"
1729 vcfg.Stdout = a.Objdir + "vet.stdout"
1730 if a.needFix {
1731 vcfg.FixArchive = a.Objdir + "vet.fix.zip"
1732 }
1733 vcfg.PackageVetx = make(map[string]string)
1734
1735 h := cache.NewHash("vet " + a.Package.ImportPath)
1736 fmt.Fprintf(h, "vet %q\n", b.toolID("vet"))
1737 fmt.Fprintf(h, "vetxonly %v\n", vcfg.VetxOnly)
1738
1739 vetFlags := VetFlags
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763 if a.Package.Goroot && !VetExplicit && VetTool == base.Tool("vet") {
1764
1765
1766
1767
1768
1769
1770
1771
1772 vetFlags = []string{"-unsafeptr=false"}
1773
1774
1775
1776 if cfg.CmdName != "test" {
1777 vetFlags = append(vetFlags, VetFlags...)
1778 }
1779
1780
1781
1782
1783
1784
1785
1786
1787 if cfg.CmdName == "test" {
1788 vetFlags = append(vetFlags, "-unreachable=false")
1789 }
1790 }
1791
1792
1793
1794
1795
1796
1797 fmt.Fprintf(h, "vetflags %q\n", vetFlags)
1798
1799 fmt.Fprintf(h, "pkg %q\n", a.Deps[0].actionID)
1800 for _, a1 := range a.Deps {
1801 if a1.Mode == "vet" && a1.built != "" {
1802 fmt.Fprintf(h, "vetout %q %s\n", a1.Package.ImportPath, b.fileHash(a1.built))
1803 vcfg.PackageVetx[a1.Package.ImportPath] = a1.built
1804 }
1805 }
1806 var (
1807 id = cache.ActionID(h.Sum())
1808 stdoutKey = cache.Subkey(id, "stdout")
1809 fixArchiveKey = cache.Subkey(id, "fix.zip")
1810 )
1811
1812
1813 if !cfg.BuildA {
1814 c := cache.Default()
1815
1816
1817
1818
1819 var (
1820 vetxFile string
1821 fixArchive string
1822 stdout io.Reader
1823 )
1824
1825
1826 vetxFile, _, err := cache.GetFile(c, id)
1827 if err != nil {
1828 goto cachemiss
1829 }
1830
1831
1832 if a.needFix {
1833 file, _, err := cache.GetFile(c, fixArchiveKey)
1834 if err != nil {
1835 goto cachemiss
1836 }
1837 fixArchive = file
1838 }
1839
1840
1841 file, _, err := cache.GetFile(c, stdoutKey)
1842 if err != nil {
1843 goto cachemiss
1844 }
1845 f, err := os.Open(file)
1846 if err != nil {
1847 goto cachemiss
1848 }
1849 defer f.Close()
1850 stdout = f
1851
1852
1853 a.built = vetxFile
1854 a.FixArchive = fixArchive
1855 if err := VetHandleStdout(stdout); err != nil {
1856 return err
1857 }
1858
1859 return nil
1860 }
1861 cachemiss:
1862
1863 js, err := json.Marshal(vcfg)
1864 if err != nil {
1865 return fmt.Errorf("internal error marshaling vet config: %v", err)
1866 }
1867 if err := sh.writeFile(a.Objdir+"vet.cfg", js); err != nil {
1868 return err
1869 }
1870
1871
1872 env := b.cCompilerEnv()
1873 if cfg.BuildToolchainName == "gccgo" {
1874 env = append(env, "GCCGO="+BuildToolchain.compiler())
1875 }
1876
1877 p := a.Package
1878 tool := VetTool
1879 if tool == "" {
1880 panic("VetTool unset")
1881 }
1882
1883
1884
1885
1886
1887 out, runErr := sh.runOut(a.Deps[0].Objdir, env, cfg.BuildToolexec, tool, vetFlags, a.Objdir+"vet.cfg")
1888 runErr = sh.reportCmd(p.ImportPath, p.Dir, out, runErr)
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903 vetx, vetxErr := os.Open(vcfg.VetxOutput)
1904 if vetxErr == nil {
1905 defer vetx.Close()
1906 a.built = vcfg.VetxOutput
1907 }
1908
1909 if runErr != nil {
1910 return runErr
1911 }
1912
1913
1914 if a.needFix {
1915 if f, err := os.Open(vcfg.FixArchive); err == nil {
1916 defer f.Close()
1917 a.FixArchive = vcfg.FixArchive
1918 cache.Default().Put(fixArchiveKey, f)
1919 }
1920 }
1921
1922
1923 if f, err := os.Open(vcfg.Stdout); err == nil {
1924 defer f.Close()
1925 if err := VetHandleStdout(f); err != nil {
1926 return err
1927 }
1928 f.Seek(0, io.SeekStart)
1929 cache.Default().Put(stdoutKey, f)
1930 }
1931
1932
1933
1934 if vetxErr == nil {
1935 cache.Default().Put(id, vetx)
1936 }
1937
1938 return nil
1939 }
1940
1941 func (b *Builder) export(ctx context.Context, a *Action) error {
1942
1943 ecfg := b.buildExportConfig(a)
1944 aid := b.exportActionID(a, ecfg)
1945 if b.useCache(a, aid, a.Target, !b.IsCmdList) {
1946 e, err := cache.Default().Get(aid)
1947 if err != nil {
1948 return err
1949 }
1950 a.Package.BuildID = a.buildID
1951 a.Package.Export = cache.Default().OutputFile(e.OutputID)
1952 return nil
1953 }
1954
1955 defer b.flushOutput(a)
1956 sh := b.Shell(a)
1957 if err := sh.Mkdir(a.Objdir); err != nil {
1958 return err
1959 }
1960
1961 js, err := json.Marshal(ecfg)
1962 if err != nil {
1963 return err
1964 }
1965 in := a.Objdir + "export.cfg"
1966 if err := sh.writeFile(in, js); err != nil {
1967 return err
1968 }
1969 tool := base.Tool("export")
1970
1971 if err := sh.run(b.WorkDir, a.Package.ImportPath, nil, cfg.BuildToolexec, tool, in); err != nil {
1972 return err
1973 }
1974
1975 if err := b.updateBuildID(a, a.Target); err != nil {
1976 return err
1977 }
1978 a.built = a.Target
1979
1980 f, err := os.Open(a.built)
1981 if err != nil {
1982 return err
1983 }
1984 defer f.Close()
1985 oid, _, err := cache.Default().Put(aid, f)
1986 if err != nil {
1987 return err
1988 }
1989 a.Package.BuildID = a.buildID
1990 a.Package.Export = cache.Default().OutputFile(oid)
1991 return nil
1992 }
1993
1994 func (b *Builder) buildExportConfig(a *Action) *exportConfig {
1995 v := gover.Local()
1996 if a.Package.Module != nil {
1997 v = cmp.Or(a.Package.Module.GoVersion, gover.DefaultGoModVersion)
1998 }
1999
2000
2001
2002 srcs := actualFiles(mkAbsFiles(a.Package.Dir, a.Package.GoFiles))
2003
2004 if a.Package.UsesCgo() {
2005 for _, dep := range a.Deps {
2006 if cgo, ok := dep.Provider.(*runCgoProvider); ok {
2007 srcs = append(srcs, cgo.goFiles...)
2008 }
2009 }
2010 }
2011
2012 ecfg := &exportConfig{
2013 ImportPath: a.Package.ImportPath,
2014 GoVersion: "go" + v,
2015 GoFiles: srcs,
2016 ImportMap: make(map[string]string),
2017 PackageFile: make(map[string]string),
2018 Output: a.Target,
2019 TrimPath: a.trimpath(),
2020 }
2021 for i, s := range a.Package.Internal.RawImports {
2022 if s != "C" {
2023 ecfg.ImportMap[s] = a.Package.Imports[i]
2024 }
2025 }
2026
2027 for _, s := range a.Package.Internal.CompiledImports {
2028 ecfg.ImportMap[s] = s
2029 }
2030 for _, dep := range a.Deps {
2031
2032
2033 if dep.Mode == "export" {
2034 ecfg.PackageFile[dep.Package.ImportPath] = dep.built
2035 }
2036 }
2037 return ecfg
2038 }
2039
2040 func (b *Builder) exportActionID(a *Action, ecfg *exportConfig) cache.ActionID {
2041 h := cache.NewHash("export " + a.Package.ImportPath)
2042
2043 fmt.Fprintf(h, "export %s\n", b.toolID("export"))
2044
2045 fmt.Fprintf(h, "importPath %s\n", ecfg.ImportPath)
2046 fmt.Fprintf(h, "goVersion %s\n", ecfg.GoVersion)
2047
2048 fmt.Fprintf(h, "goos %s goarch %s\n", cfg.Goos, cfg.Goarch)
2049 b.addPackageOrigin(h, a.Package)
2050
2051 for _, file := range ecfg.GoFiles {
2052 fmt.Fprintf(h, "goFile %s %s\n", file, b.fileHash(file))
2053 }
2054
2055 for _, dep := range a.Deps {
2056 if dep.Mode == "export" {
2057 fmt.Fprintf(h, "packageFile %s=%s\n", dep.Package.ImportPath, buildExportID(dep.buildID))
2058 }
2059 }
2060 return cache.ActionID(h.Sum())
2061 }
2062
2063 var stdoutMu sync.Mutex
2064
2065
2066 func copyToStdout(r io.Reader) error {
2067 stdoutMu.Lock()
2068 defer stdoutMu.Unlock()
2069 if _, err := io.Copy(os.Stdout, r); err != nil {
2070 return fmt.Errorf("copying vet tool stdout: %w", err)
2071 }
2072 return nil
2073 }
2074
2075
2076 func (b *Builder) linkActionID(a *Action) cache.ActionID {
2077 p := a.Package
2078 h := cache.NewHash("link " + p.ImportPath)
2079
2080
2081 fmt.Fprintf(h, "link\n")
2082
2083
2084
2085 fmt.Fprintf(h, "buildmode %s goos %s goarch %s\n", ldBuildmode, cfg.Goos, cfg.Goarch)
2086 fmt.Fprintf(h, "import %q\n", p.ImportPath)
2087 fmt.Fprintf(h, "omitdebug %v standard %v local %v prefix %q\n", p.Internal.OmitDebug, p.Standard, p.Internal.Local, p.Internal.LocalPrefix)
2088 fmt.Fprintf(h, "defaultgodebug %q\n", p.DefaultGODEBUG)
2089 if cfg.BuildTrimpath {
2090 fmt.Fprintln(h, "trimpath")
2091 }
2092
2093
2094 b.printLinkerConfig(h, p)
2095
2096
2097 for _, a1 := range a.Deps {
2098 p1 := a1.Package
2099 if p1 != nil {
2100 if a1.built != "" || a1.buildID != "" {
2101 buildID := a1.buildID
2102 if buildID == "" {
2103 buildID = b.buildID(a1.built)
2104 }
2105 fmt.Fprintf(h, "packagefile %s=%s\n", p1.ImportPath, buildObjectID(buildID))
2106 }
2107
2108
2109
2110
2111 if p1.Name == "main" {
2112 fmt.Fprintf(h, "packagemain %s\n", buildActionID(a1.buildID)+buildIDSeparator+buildObjectID(a1.buildID))
2113 }
2114 if p1.Shlib != "" {
2115 fmt.Fprintf(h, "packageshlib %s=%s\n", p1.ImportPath, buildObjectID(b.buildID(p1.Shlib)))
2116 }
2117 }
2118 }
2119
2120 return h.Sum()
2121 }
2122
2123
2124
2125 func (b *Builder) printLinkerConfig(h io.Writer, p *load.Package) {
2126 switch cfg.BuildToolchainName {
2127 default:
2128 base.Fatalf("linkActionID: unknown toolchain %q", cfg.BuildToolchainName)
2129
2130 case "gc":
2131 fmt.Fprintf(h, "link %s %q %s\n", b.toolID("link"), forcedLdflags, ldBuildmode)
2132 if p != nil {
2133 fmt.Fprintf(h, "linkflags %q\n", p.Internal.Ldflags)
2134 }
2135
2136
2137 key, val, _ := cfg.GetArchEnv()
2138 fmt.Fprintf(h, "%s=%s\n", key, val)
2139
2140 if cfg.CleanGOEXPERIMENT != "" {
2141 fmt.Fprintf(h, "GOEXPERIMENT=%q\n", cfg.CleanGOEXPERIMENT)
2142 }
2143
2144
2145 fmt.Fprintf(h, "GOROOT=%s\n", linkGOROOT())
2146
2147
2148 fmt.Fprintf(h, "GO_EXTLINK_ENABLED=%s\n", cfg.Getenv("GO_EXTLINK_ENABLED"))
2149
2150
2151
2152
2153 case "gccgo":
2154 id, _, err := b.gccgoToolID(BuildToolchain.linker(), "go")
2155 if err != nil {
2156 base.Fatalf("%v", err)
2157 }
2158 fmt.Fprintf(h, "link %s %s\n", id, ldBuildmode)
2159
2160 }
2161 }
2162
2163
2164
2165 func (b *Builder) link(ctx context.Context, a *Action) (err error) {
2166 if b.useCache(a, b.linkActionID(a), a.Package.Target, !b.IsCmdList) || b.IsCmdList {
2167 return nil
2168 }
2169 defer b.flushOutput(a)
2170
2171 sh := b.Shell(a)
2172 if err := sh.Mkdir(a.Objdir); err != nil {
2173 return err
2174 }
2175
2176 importcfg := a.Objdir + "importcfg.link"
2177 if err := b.writeLinkImportcfg(a, importcfg); err != nil {
2178 return err
2179 }
2180
2181 if err := AllowInstall(a); err != nil {
2182 return err
2183 }
2184
2185
2186 dir, _ := filepath.Split(a.Target)
2187 if dir != "" {
2188 if err := sh.Mkdir(dir); err != nil {
2189 return err
2190 }
2191 }
2192
2193 if err := BuildToolchain.ld(b, a, a.Target, importcfg, a.Deps[0].built); err != nil {
2194 return err
2195 }
2196
2197
2198 if err := b.updateBuildID(a, a.Target); err != nil {
2199 return err
2200 }
2201
2202 a.built = a.Target
2203 return nil
2204 }
2205
2206 func (b *Builder) writeLinkImportcfg(a *Action, file string) error {
2207
2208 var icfg bytes.Buffer
2209 for _, a1 := range a.Deps {
2210 p1 := a1.Package
2211 if p1 == nil {
2212 continue
2213 }
2214 fmt.Fprintf(&icfg, "packagefile %s=%s\n", p1.ImportPath, a1.built)
2215 if p1.Shlib != "" {
2216 fmt.Fprintf(&icfg, "packageshlib %s=%s\n", p1.ImportPath, p1.Shlib)
2217 }
2218 }
2219 info := ""
2220 if a.Package.Internal.BuildInfo != nil {
2221 info = a.Package.Internal.BuildInfo.String()
2222 }
2223 fmt.Fprintf(&icfg, "modinfo %q\n", modload.ModInfoData(info))
2224 return b.Shell(a).writeFile(file, icfg.Bytes())
2225 }
2226
2227
2228
2229 func (b *Builder) PkgconfigCmd() string {
2230 return envList("PKG_CONFIG", cfg.DefaultPkgConfig)[0]
2231 }
2232
2233
2234
2235
2236
2237
2238
2239 func splitPkgConfigOutput(out []byte) ([]string, error) {
2240 if len(out) == 0 {
2241 return nil, nil
2242 }
2243 var flags []string
2244 flag := make([]byte, 0, len(out))
2245 didQuote := false
2246 escaped := false
2247 quote := byte(0)
2248
2249 for _, c := range out {
2250 if escaped {
2251 if quote == '"' {
2252
2253
2254
2255 switch c {
2256 case '$', '`', '"', '\\', '\n':
2257
2258 default:
2259
2260 flag = append(flag, '\\', c)
2261 escaped = false
2262 continue
2263 }
2264 }
2265
2266 if c == '\n' {
2267
2268
2269 } else {
2270 flag = append(flag, c)
2271 }
2272 escaped = false
2273 continue
2274 }
2275
2276 if quote != 0 && c == quote {
2277 quote = 0
2278 continue
2279 }
2280 switch quote {
2281 case '\'':
2282
2283 flag = append(flag, c)
2284 continue
2285 case '"':
2286
2287
2288 switch c {
2289 case '`', '$', '\\':
2290 default:
2291 flag = append(flag, c)
2292 continue
2293 }
2294 }
2295
2296
2297
2298 switch c {
2299 case '|', '&', ';', '<', '>', '(', ')', '$', '`':
2300 return nil, fmt.Errorf("unexpected shell character %q in pkgconf output", c)
2301
2302 case '\\':
2303
2304
2305 escaped = true
2306 continue
2307
2308 case '"', '\'':
2309 quote = c
2310 didQuote = true
2311 continue
2312
2313 case ' ', '\t', '\n':
2314 if len(flag) > 0 || didQuote {
2315 flags = append(flags, string(flag))
2316 }
2317 flag, didQuote = flag[:0], false
2318 continue
2319 }
2320
2321 flag = append(flag, c)
2322 }
2323
2324
2325
2326
2327 if quote != 0 {
2328 return nil, errors.New("unterminated quoted string in pkgconf output")
2329 }
2330 if escaped {
2331 return nil, errors.New("broken character escaping in pkgconf output")
2332 }
2333
2334 if len(flag) > 0 || didQuote {
2335 flags = append(flags, string(flag))
2336 }
2337 return flags, nil
2338 }
2339
2340
2341 func (b *Builder) getPkgConfigFlags(a *Action, p *load.Package) (cflags, ldflags []string, err error) {
2342 sh := b.Shell(a)
2343 if pcargs := p.CgoPkgConfig; len(pcargs) > 0 {
2344
2345
2346 var pcflags []string
2347 var pkgs []string
2348 for _, pcarg := range pcargs {
2349 if pcarg == "--" {
2350
2351 } else if strings.HasPrefix(pcarg, "--") {
2352 pcflags = append(pcflags, pcarg)
2353 } else {
2354 pkgs = append(pkgs, pcarg)
2355 }
2356 }
2357 for _, pkg := range pkgs {
2358 if !validPkgConfigName(pkg) {
2359 return nil, nil, fmt.Errorf("invalid pkg-config package name: %s", pkg)
2360 }
2361 }
2362
2363 if err := checkPkgConfigFlags("", "pkg-config", pcflags); err != nil {
2364 return nil, nil, err
2365 }
2366
2367 var out []byte
2368 out, err = sh.runOut(p.Dir, nil, b.PkgconfigCmd(), "--cflags", pcflags, "--", pkgs)
2369 if err != nil {
2370 desc := b.PkgconfigCmd() + " --cflags " + strings.Join(pcflags, " ") + " -- " + strings.Join(pkgs, " ")
2371 return nil, nil, sh.reportCmd(desc, "", out, err)
2372 }
2373 if len(out) > 0 {
2374 cflags, err = splitPkgConfigOutput(bytes.TrimSpace(out))
2375 if err != nil {
2376 return nil, nil, err
2377 }
2378 if err := checkCompilerFlags("CFLAGS", "pkg-config --cflags", cflags); err != nil {
2379 return nil, nil, err
2380 }
2381 }
2382 out, err = sh.runOut(p.Dir, nil, b.PkgconfigCmd(), "--libs", pcflags, "--", pkgs)
2383 if err != nil {
2384 desc := b.PkgconfigCmd() + " --libs " + strings.Join(pcflags, " ") + " -- " + strings.Join(pkgs, " ")
2385 return nil, nil, sh.reportCmd(desc, "", out, err)
2386 }
2387 if len(out) > 0 {
2388
2389
2390 ldflags, err = splitPkgConfigOutput(bytes.TrimSpace(out))
2391 if err != nil {
2392 return nil, nil, err
2393 }
2394 if err := checkLinkerFlags("LDFLAGS", "pkg-config --libs", ldflags); err != nil {
2395 return nil, nil, err
2396 }
2397 }
2398 }
2399
2400 return
2401 }
2402
2403 func (b *Builder) installShlibname(ctx context.Context, a *Action) error {
2404 if err := AllowInstall(a); err != nil {
2405 return err
2406 }
2407
2408 sh := b.Shell(a)
2409 a1 := a.Deps[0]
2410 if !cfg.BuildN {
2411 if err := sh.Mkdir(filepath.Dir(a.Target)); err != nil {
2412 return err
2413 }
2414 }
2415 return sh.writeFile(a.Target, []byte(filepath.Base(a1.Target)+"\n"))
2416 }
2417
2418 func (b *Builder) linkSharedActionID(a *Action) cache.ActionID {
2419 h := cache.NewHash("linkShared")
2420
2421
2422 fmt.Fprintf(h, "linkShared\n")
2423 fmt.Fprintf(h, "goos %s goarch %s\n", cfg.Goos, cfg.Goarch)
2424
2425
2426 b.printLinkerConfig(h, nil)
2427
2428
2429 for _, a1 := range a.Deps {
2430 p1 := a1.Package
2431 if a1.built == "" {
2432 continue
2433 }
2434 if p1 != nil {
2435 fmt.Fprintf(h, "packagefile %s=%s\n", p1.ImportPath, buildObjectID(b.buildID(a1.built)))
2436 if p1.Shlib != "" {
2437 fmt.Fprintf(h, "packageshlib %s=%s\n", p1.ImportPath, buildObjectID(b.buildID(p1.Shlib)))
2438 }
2439 }
2440 }
2441
2442 for _, a1 := range a.Deps[0].Deps {
2443 p1 := a1.Package
2444 fmt.Fprintf(h, "top %s=%s\n", p1.ImportPath, buildObjectID(b.buildID(a1.built)))
2445 }
2446
2447 return h.Sum()
2448 }
2449
2450 func (b *Builder) linkShared(ctx context.Context, a *Action) (err error) {
2451 if b.useCache(a, b.linkSharedActionID(a), a.Target, !b.IsCmdList) || b.IsCmdList {
2452 return nil
2453 }
2454 defer b.flushOutput(a)
2455
2456 if err := AllowInstall(a); err != nil {
2457 return err
2458 }
2459
2460 if err := b.Shell(a).Mkdir(a.Objdir); err != nil {
2461 return err
2462 }
2463
2464 importcfg := a.Objdir + "importcfg.link"
2465 if err := b.writeLinkImportcfg(a, importcfg); err != nil {
2466 return err
2467 }
2468
2469
2470
2471 a.built = a.Target
2472 return BuildToolchain.ldShared(b, a, a.Deps[0].Deps, a.Target, importcfg, a.Deps)
2473 }
2474
2475
2476 func BuildInstallFunc(b *Builder, ctx context.Context, a *Action) (err error) {
2477 defer func() {
2478 if err != nil {
2479
2480
2481
2482 sep, path := "", ""
2483 if a.Package != nil {
2484 sep, path = " ", a.Package.ImportPath
2485 }
2486 err = fmt.Errorf("go %s%s%s: %v", cfg.CmdName, sep, path, err)
2487 }
2488 }()
2489 sh := b.Shell(a)
2490
2491 a1 := a.Deps[0]
2492 a.buildID = a1.buildID
2493 if a.json != nil {
2494 a.json.BuildID = a.buildID
2495 }
2496
2497
2498
2499
2500
2501
2502 if a1.built == a.Target {
2503 a.built = a.Target
2504 if !a.buggyInstall {
2505 b.cleanup(a1)
2506 }
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525 if !a.buggyInstall && !b.IsCmdList {
2526 if cfg.BuildN {
2527 sh.ShowCmd("", "touch %s", a.Target)
2528 } else if err := AllowInstall(a); err == nil {
2529 now := time.Now()
2530 os.Chtimes(a.Target, now, now)
2531 }
2532 }
2533 return nil
2534 }
2535
2536
2537
2538 if b.IsCmdList {
2539 a.built = a1.built
2540 return nil
2541 }
2542 if err := AllowInstall(a); err != nil {
2543 return err
2544 }
2545
2546 if err := sh.Mkdir(a.Objdir); err != nil {
2547 return err
2548 }
2549
2550 perm := fs.FileMode(0666)
2551 if a1.Mode == "link" {
2552 switch cfg.BuildBuildmode {
2553 case "c-archive", "c-shared", "plugin":
2554 default:
2555 perm = 0777
2556 }
2557 }
2558
2559
2560 dir, _ := filepath.Split(a.Target)
2561 if dir != "" {
2562 if err := sh.Mkdir(dir); err != nil {
2563 return err
2564 }
2565 }
2566
2567 if !a.buggyInstall {
2568 defer b.cleanup(a1)
2569 }
2570
2571 if err := sh.moveOrCopyFile(a.Target, a1.built, perm, false); err != nil {
2572 return err
2573 }
2574
2575
2576
2577 if a1.Mode == "link" && cfg.CmdName != "install" && a.Target != os.DevNull {
2578 dsym := filepath.Join(a1.built+".dSYM", "Contents", "Resources", "DWARF", filepath.Base(a1.built))
2579 if _, err := os.Stat(dsym); err == nil {
2580 hdr := filepath.Join(a.Target+".dSYM", "Contents", "Resources", "DWARF")
2581 if err := sh.Mkdir(hdr); err != nil {
2582 return err
2583 }
2584 if err := sh.moveOrCopyFile(filepath.Join(hdr, filepath.Base(a.Target)), dsym, 0666, false); err != nil {
2585 return err
2586 }
2587 } else if !cfg.BuildN {
2588
2589 if err := sh.RemoveAll(a.Target + ".dSYM"); err != nil {
2590 return err
2591 }
2592 }
2593 }
2594
2595 return nil
2596 }
2597
2598
2599
2600
2601
2602
2603 var AllowInstall = func(*Action) error { return nil }
2604
2605
2606
2607
2608
2609 func (b *Builder) cleanup(a *Action) {
2610 if !cfg.BuildWork {
2611 b.Shell(a).RemoveAll(a.Objdir)
2612 }
2613 }
2614
2615
2616 func (b *Builder) installHeader(ctx context.Context, a *Action) error {
2617 sh := b.Shell(a)
2618
2619 src := a.Objdir + "_cgo_install.h"
2620 if _, err := os.Stat(src); os.IsNotExist(err) {
2621
2622
2623
2624
2625
2626 if cfg.BuildX {
2627 sh.ShowCmd("", "# %s not created", src)
2628 }
2629 return nil
2630 }
2631
2632 if err := AllowInstall(a); err != nil {
2633 return err
2634 }
2635
2636 dir, _ := filepath.Split(a.Target)
2637 if dir != "" {
2638 if err := sh.Mkdir(dir); err != nil {
2639 return err
2640 }
2641 }
2642
2643 return sh.moveOrCopyFile(a.Target, src, 0666, true)
2644 }
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654 func (b *Builder) cover(a *Action, infiles, outfiles []string, varName, mode, covMetaFileName, coverCfg string) ([]string, error) {
2655 pkgcfg := a.Objdir + "pkgcfg.txt"
2656 covoutputs := a.Objdir + "coveroutfiles.txt"
2657 odir := filepath.Dir(outfiles[0])
2658 cv := filepath.Join(odir, "covervars.go")
2659 outfiles = append([]string{cv}, outfiles...)
2660 if err := b.writeCoverPkgInputs(a, pkgcfg, covMetaFileName, coverCfg, covoutputs, outfiles); err != nil {
2661 return nil, err
2662 }
2663 args := []string{base.Tool("cover"),
2664 "-pkgcfg", pkgcfg,
2665 "-mode", mode,
2666 "-var", varName,
2667 "-outfilelist", covoutputs,
2668 }
2669 args = append(args, infiles...)
2670 if err := b.Shell(a).run(a.Objdir, "", nil,
2671 cfg.BuildToolexec, args); err != nil {
2672 return nil, err
2673 }
2674 return outfiles, nil
2675 }
2676
2677 func coverConfig(p *load.Package, covMetaFileName, outConfig string) covcmd.CoverPkgConfig {
2678 pcfg := covcmd.CoverPkgConfig{
2679 PkgPath: p.ImportPath,
2680 PkgName: p.Name,
2681
2682
2683
2684
2685 Granularity: "perblock",
2686 OutConfig: outConfig,
2687 Local: p.Internal.Local,
2688 EmitMetaFile: covMetaFileName,
2689 }
2690 if p.Module != nil {
2691 pcfg.ModulePath = p.Module.Path
2692 }
2693 return pcfg
2694 }
2695
2696 func (b *Builder) writeCoverPkgInputs(a *Action, pconfigfile, covMetaFileName, coverCfg, covoutputsfile string, outfiles []string) error {
2697 sh := b.Shell(a)
2698 p := a.Package
2699 pcfg := coverConfig(p, covMetaFileName, coverCfg)
2700 data, err := json.Marshal(pcfg)
2701 if err != nil {
2702 return err
2703 }
2704 if err := sh.writeFile(pconfigfile, data); err != nil {
2705 return err
2706 }
2707 var sb strings.Builder
2708 for i := range outfiles {
2709 fmt.Fprintf(&sb, "%s\n", outfiles[i])
2710 }
2711 return sh.writeFile(covoutputsfile, []byte(sb.String()))
2712 }
2713
2714 var objectMagic = [][]byte{
2715 {'!', '<', 'a', 'r', 'c', 'h', '>', '\n'},
2716 {'<', 'b', 'i', 'g', 'a', 'f', '>', '\n'},
2717 {'\x7F', 'E', 'L', 'F'},
2718 {0xFE, 0xED, 0xFA, 0xCE},
2719 {0xFE, 0xED, 0xFA, 0xCF},
2720 {0xCE, 0xFA, 0xED, 0xFE},
2721 {0xCF, 0xFA, 0xED, 0xFE},
2722 {0x4d, 0x5a, 0x90, 0x00, 0x03, 0x00},
2723 {0x4d, 0x5a, 0x78, 0x00, 0x01, 0x00},
2724 {0x00, 0x00, 0x01, 0xEB},
2725 {0x00, 0x00, 0x8a, 0x97},
2726 {0x00, 0x00, 0x06, 0x47},
2727 {0x00, 0x61, 0x73, 0x6D},
2728 {0x01, 0xDF},
2729 {0x01, 0xF7},
2730 }
2731
2732 func isObject(s string) bool {
2733 f, err := os.Open(s)
2734 if err != nil {
2735 return false
2736 }
2737 defer f.Close()
2738 buf := make([]byte, 64)
2739 io.ReadFull(f, buf)
2740 for _, magic := range objectMagic {
2741 if bytes.HasPrefix(buf, magic) {
2742 return true
2743 }
2744 }
2745 return false
2746 }
2747
2748
2749
2750
2751 func (b *Builder) cCompilerEnv() []string {
2752 return []string{"TERM=dumb"}
2753 }
2754
2755
2756
2757
2758
2759
2760 func mkAbs(dir, f string) string {
2761
2762
2763
2764
2765 if filepath.IsAbs(f) || strings.HasPrefix(f, "$WORK") {
2766 return f
2767 }
2768 return filepath.Join(dir, f)
2769 }
2770
2771 type toolchain interface {
2772
2773
2774 gc(b *Builder, a *Action, archive string, importcfg, embedcfg []byte, symabis string, asmhdr bool, pgoProfile, coverCfg string, gofiles []string) (ofile string, out []byte, compile *shellCmd, err error)
2775
2776
2777 cc(b *Builder, a *Action, ofile, cfile string) error
2778
2779
2780 asm(b *Builder, a *Action, sfiles []string) ([]string, error)
2781
2782
2783 symabis(b *Builder, a *Action, sfiles []string) (string, error)
2784
2785
2786
2787 pack(b *Builder, a *Action, afile string, ofiles []string) error
2788
2789 ld(b *Builder, root *Action, targetPath, importcfg, mainpkg string) error
2790
2791 ldShared(b *Builder, root *Action, toplevelactions []*Action, targetPath, importcfg string, allactions []*Action) error
2792
2793 compiler() string
2794 linker() string
2795 }
2796
2797 type noToolchain struct{}
2798
2799 func noCompiler() error {
2800 log.Fatalf("unknown compiler %q", cfg.BuildContext.Compiler)
2801 return nil
2802 }
2803
2804 func (noToolchain) compiler() string {
2805 noCompiler()
2806 return ""
2807 }
2808
2809 func (noToolchain) linker() string {
2810 noCompiler()
2811 return ""
2812 }
2813
2814 func (noToolchain) gc(b *Builder, a *Action, archive string, importcfg, embedcfg []byte, symabis string, asmhdr bool, pgoProfile, coverCfg string, gofiles []string) (ofile string, out []byte, compile *shellCmd, err error) {
2815 return "", nil, nil, noCompiler()
2816 }
2817
2818 func (noToolchain) asm(b *Builder, a *Action, sfiles []string) ([]string, error) {
2819 return nil, noCompiler()
2820 }
2821
2822 func (noToolchain) symabis(b *Builder, a *Action, sfiles []string) (string, error) {
2823 return "", noCompiler()
2824 }
2825
2826 func (noToolchain) pack(b *Builder, a *Action, afile string, ofiles []string) error {
2827 return noCompiler()
2828 }
2829
2830 func (noToolchain) ld(b *Builder, root *Action, targetPath, importcfg, mainpkg string) error {
2831 return noCompiler()
2832 }
2833
2834 func (noToolchain) ldShared(b *Builder, root *Action, toplevelactions []*Action, targetPath, importcfg string, allactions []*Action) error {
2835 return noCompiler()
2836 }
2837
2838 func (noToolchain) cc(b *Builder, a *Action, ofile, cfile string) error {
2839 return noCompiler()
2840 }
2841
2842
2843 func (b *Builder) gcc(a *Action, workdir, out string, flags []string, cfile string) error {
2844 p := a.Package
2845 return b.ccompile(a, out, flags, cfile, b.GccCmd(p.Dir, workdir))
2846 }
2847
2848
2849 func (b *Builder) gas(a *Action, workdir, out string, flags []string, sfile string) error {
2850 p := a.Package
2851 data, err := os.ReadFile(sfile)
2852 if err == nil {
2853 if bytes.HasPrefix(data, []byte("TEXT")) || bytes.Contains(data, []byte("\nTEXT")) ||
2854 bytes.HasPrefix(data, []byte("DATA")) || bytes.Contains(data, []byte("\nDATA")) ||
2855 bytes.HasPrefix(data, []byte("GLOBL")) || bytes.Contains(data, []byte("\nGLOBL")) {
2856 return fmt.Errorf("package using cgo has Go assembly file %s", sfile)
2857 }
2858 }
2859 return b.ccompile(a, out, flags, sfile, b.GccCmd(p.Dir, workdir))
2860 }
2861
2862
2863 func (b *Builder) gxx(a *Action, workdir, out string, flags []string, cxxfile string) error {
2864 p := a.Package
2865 return b.ccompile(a, out, flags, cxxfile, b.GxxCmd(p.Dir, workdir))
2866 }
2867
2868
2869 func (b *Builder) gfortran(a *Action, workdir, out string, flags []string, ffile string) error {
2870 p := a.Package
2871 return b.ccompile(a, out, flags, ffile, b.gfortranCmd(p.Dir, workdir))
2872 }
2873
2874
2875 func (b *Builder) ccompile(a *Action, outfile string, flags []string, file string, compiler []string) error {
2876 p := a.Package
2877 sh := b.Shell(a)
2878 file = mkAbs(p.Dir, file)
2879 outfile = mkAbs(p.Dir, outfile)
2880
2881 flags = slices.Clip(flags)
2882
2883
2884
2885
2886
2887
2888 if b.gccSupportsFlag(compiler, "-fdebug-prefix-map=a=b") {
2889 if cfg.BuildTrimpath || p.Goroot {
2890 prefixMapFlag := "-fdebug-prefix-map"
2891 if b.gccSupportsFlag(compiler, "-ffile-prefix-map=a=b") {
2892 prefixMapFlag = "-ffile-prefix-map"
2893 }
2894
2895
2896
2897 var from, toPath string
2898 if m := p.Module; m == nil {
2899 if p.Root == "" {
2900 from = p.Dir
2901 toPath = p.ImportPath
2902 } else if p.Goroot {
2903 from = p.Root
2904 toPath = "GOROOT"
2905 } else {
2906 from = p.Root
2907 toPath = "GOPATH"
2908 }
2909 } else if m.Dir == "" {
2910
2911
2912 from = b.getVendorDir()
2913 toPath = "vendor"
2914 } else {
2915 from = m.Dir
2916 toPath = m.Path
2917 if m.Version != "" {
2918 toPath += "@" + m.Version
2919 }
2920 }
2921
2922
2923
2924 var to string
2925 if cfg.BuildContext.GOOS == "windows" {
2926 to = filepath.Join(`\\_\_`, toPath)
2927 } else {
2928 to = filepath.Join("/_", toPath)
2929 }
2930 flags = append(slices.Clip(flags), prefixMapFlag+"="+from+"="+to)
2931 }
2932 }
2933
2934
2935
2936 if b.gccSupportsFlag(compiler, "-frandom-seed=1") {
2937 flags = append(flags, "-frandom-seed="+buildid.HashToString(a.actionID))
2938 }
2939
2940 overlayPath := file
2941 if p, ok := a.nonGoOverlay[overlayPath]; ok {
2942 overlayPath = p
2943 }
2944 output, err := sh.runOut(filepath.Dir(overlayPath), b.cCompilerEnv(), compiler, flags, "-o", outfile, "-c", filepath.Base(overlayPath))
2945
2946
2947
2948
2949
2950
2951
2952
2953
2954 if bytes.Contains(output, []byte("DWARF2 only supports one section per compilation unit")) {
2955 newFlags := make([]string, 0, len(flags))
2956 for _, f := range flags {
2957 if !strings.HasPrefix(f, "-g") {
2958 newFlags = append(newFlags, f)
2959 }
2960 }
2961 if len(newFlags) < len(flags) {
2962 return b.ccompile(a, outfile, newFlags, file, compiler)
2963 }
2964 }
2965
2966 if len(output) > 0 && err == nil && os.Getenv("GO_BUILDER_NAME") != "" {
2967 output = append(output, "C compiler warning promoted to error on Go builders\n"...)
2968 err = errors.New("warning promoted to error")
2969 }
2970
2971 return sh.reportCmd("", "", output, err)
2972 }
2973
2974
2975 func (b *Builder) gccld(a *Action, objdir, outfile string, flags []string, objs []string) error {
2976 p := a.Package
2977 sh := b.Shell(a)
2978 var cmd []string
2979 if len(p.CXXFiles) > 0 || len(p.SwigCXXFiles) > 0 {
2980 cmd = b.GxxCmd(p.Dir, objdir)
2981 } else {
2982 cmd = b.GccCmd(p.Dir, objdir)
2983 }
2984
2985 cmdargs := []any{cmd, "-o", outfile, objs, flags}
2986 _, err := sh.runOut(base.Cwd(), b.cCompilerEnv(), cmdargs...)
2987
2988
2989
2990 if cfg.BuildN || cfg.BuildX {
2991 saw := "succeeded"
2992 if err != nil {
2993 saw = "failed"
2994 }
2995 sh.ShowCmd("", "%s # test for internal linking errors (%s)", joinUnambiguously(str.StringList(cmdargs...)), saw)
2996 }
2997
2998 return err
2999 }
3000
3001
3002
3003 func (b *Builder) GccCmd(incdir, workdir string) []string {
3004 return b.compilerCmd(b.ccExe(), incdir, workdir)
3005 }
3006
3007
3008
3009 func (b *Builder) GxxCmd(incdir, workdir string) []string {
3010 return b.compilerCmd(b.cxxExe(), incdir, workdir)
3011 }
3012
3013
3014 func (b *Builder) gfortranCmd(incdir, workdir string) []string {
3015 return b.compilerCmd(b.fcExe(), incdir, workdir)
3016 }
3017
3018
3019 func (b *Builder) ccExe() []string {
3020 return envList("CC", cfg.DefaultCC(cfg.Goos, cfg.Goarch))
3021 }
3022
3023
3024 func (b *Builder) cxxExe() []string {
3025 return envList("CXX", cfg.DefaultCXX(cfg.Goos, cfg.Goarch))
3026 }
3027
3028
3029 func (b *Builder) fcExe() []string {
3030 return envList("FC", "gfortran")
3031 }
3032
3033
3034
3035 func (b *Builder) compilerCmd(compiler []string, incdir, workdir string) []string {
3036 a := append(compiler, "-I", incdir)
3037
3038
3039
3040 if cfg.Goos != "windows" {
3041 a = append(a, "-fPIC")
3042 }
3043 a = append(a, b.gccArchArgs()...)
3044
3045
3046 if cfg.BuildContext.CgoEnabled {
3047 a = append(a, "-pthread")
3048 }
3049
3050 if cfg.Goos == "aix" {
3051
3052 a = append(a, "-mcmodel=large")
3053 }
3054
3055
3056 if b.gccSupportsFlag(compiler, "-fno-caret-diagnostics") {
3057 a = append(a, "-fno-caret-diagnostics")
3058 }
3059
3060 if b.gccSupportsFlag(compiler, "-Qunused-arguments") {
3061 a = append(a, "-Qunused-arguments")
3062 }
3063
3064
3065
3066
3067 if b.gccSupportsFlag(compiler, "-Wl,--no-gc-sections") {
3068 a = append(a, "-Wl,--no-gc-sections")
3069 }
3070
3071
3072 a = append(a, "-fmessage-length=0")
3073
3074
3075 if b.gccSupportsFlag(compiler, "-fdebug-prefix-map=a=b") {
3076 if workdir == "" {
3077 workdir = b.WorkDir
3078 }
3079 workdir = strings.TrimSuffix(workdir, string(filepath.Separator))
3080 if b.gccSupportsFlag(compiler, "-ffile-prefix-map=a=b") {
3081 a = append(a, "-ffile-prefix-map="+workdir+"=/tmp/go-build")
3082 } else {
3083 a = append(a, "-fdebug-prefix-map="+workdir+"=/tmp/go-build")
3084 }
3085 }
3086
3087
3088
3089 if b.gccSupportsFlag(compiler, "-gno-record-gcc-switches") {
3090 a = append(a, "-gno-record-gcc-switches")
3091 }
3092
3093
3094
3095
3096 if cfg.Goos == "darwin" || cfg.Goos == "ios" {
3097 a = append(a, "-fno-common")
3098 }
3099
3100 return a
3101 }
3102
3103
3104
3105
3106
3107 func (b *Builder) gccNoPie(linker []string) string {
3108 if b.gccSupportsFlag(linker, "-no-pie") {
3109 return "-no-pie"
3110 }
3111 if b.gccSupportsFlag(linker, "-nopie") {
3112 return "-nopie"
3113 }
3114 return ""
3115 }
3116
3117
3118 func (b *Builder) gccSupportsFlag(compiler []string, flag string) bool {
3119
3120
3121
3122 sh := b.BackgroundShell()
3123
3124 key := [2]string{compiler[0], flag}
3125
3126
3127
3128
3129
3130
3131
3132
3133
3134
3135
3136
3137
3138
3139
3140
3141
3142 tmp := os.DevNull
3143 if runtime.GOOS == "windows" || runtime.GOOS == "ios" {
3144 f, err := os.CreateTemp(b.WorkDir, "")
3145 if err != nil {
3146 return false
3147 }
3148 f.Close()
3149 tmp = f.Name()
3150 defer os.Remove(tmp)
3151 }
3152
3153 cmdArgs := str.StringList(compiler, flag)
3154 if strings.HasPrefix(flag, "-Wl,") {
3155 ldflags, err := buildFlags("LDFLAGS", DefaultCFlags, nil, checkLinkerFlags)
3156 if err != nil {
3157 return false
3158 }
3159 cmdArgs = append(cmdArgs, ldflags...)
3160 } else {
3161 cflags, err := buildFlags("CFLAGS", DefaultCFlags, nil, checkCompilerFlags)
3162 if err != nil {
3163 return false
3164 }
3165 cmdArgs = append(cmdArgs, cflags...)
3166 cmdArgs = append(cmdArgs, "-c")
3167 }
3168
3169 cmdArgs = append(cmdArgs, "-x", "c", "-", "-o", tmp)
3170
3171 if cfg.BuildN {
3172 sh.ShowCmd(b.WorkDir, "%s || true", joinUnambiguously(cmdArgs))
3173 return false
3174 }
3175
3176
3177 compilerID, cacheOK := b.gccCompilerID(compiler[0])
3178
3179 b.exec.Lock()
3180 defer b.exec.Unlock()
3181 if b, ok := b.flagCache[key]; ok {
3182 return b
3183 }
3184 if b.flagCache == nil {
3185 b.flagCache = make(map[[2]string]bool)
3186 }
3187
3188
3189 var flagID cache.ActionID
3190 if cacheOK {
3191 flagID = cache.Subkey(compilerID, "gccSupportsFlag "+flag)
3192 if data, _, err := cache.GetBytes(cache.Default(), flagID); err == nil {
3193 supported := string(data) == "true"
3194 b.flagCache[key] = supported
3195 return supported
3196 }
3197 }
3198
3199 if cfg.BuildX {
3200 sh.ShowCmd(b.WorkDir, "%s || true", joinUnambiguously(cmdArgs))
3201 }
3202 cmd := exec.Command(cmdArgs[0], cmdArgs[1:]...)
3203 cmd.Dir = b.WorkDir
3204 cmd.Env = append(cmd.Environ(), "LC_ALL=C")
3205 out, _ := cmd.CombinedOutput()
3206
3207
3208
3209
3210
3211
3212 supported := !bytes.Contains(out, []byte("unrecognized")) &&
3213 !bytes.Contains(out, []byte("unknown")) &&
3214 !bytes.Contains(out, []byte("unrecognised")) &&
3215 !bytes.Contains(out, []byte("is not supported")) &&
3216 !bytes.Contains(out, []byte("not recognized")) &&
3217 !bytes.Contains(out, []byte("unsupported"))
3218
3219 if cacheOK {
3220 s := "false"
3221 if supported {
3222 s = "true"
3223 }
3224 cache.PutBytes(cache.Default(), flagID, []byte(s))
3225 }
3226
3227 b.flagCache[key] = supported
3228 return supported
3229 }
3230
3231
3232 func statString(info os.FileInfo) string {
3233 return fmt.Sprintf("stat %d %x %v %v\n", info.Size(), uint64(info.Mode()), info.ModTime(), info.IsDir())
3234 }
3235
3236
3237
3238
3239
3240
3241 func (b *Builder) gccCompilerID(compiler string) (id cache.ActionID, ok bool) {
3242
3243
3244
3245 sh := b.BackgroundShell()
3246
3247 if cfg.BuildN {
3248 sh.ShowCmd(b.WorkDir, "%s || true", joinUnambiguously([]string{compiler, "--version"}))
3249 return cache.ActionID{}, false
3250 }
3251
3252 b.exec.Lock()
3253 defer b.exec.Unlock()
3254
3255 if id, ok := b.gccCompilerIDCache[compiler]; ok {
3256 return id, ok
3257 }
3258
3259
3260
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273 exe, err := pathcache.LookPath(compiler)
3274 if err != nil {
3275 return cache.ActionID{}, false
3276 }
3277
3278 h := cache.NewHash("gccCompilerID")
3279 fmt.Fprintf(h, "gccCompilerID %q", exe)
3280 key := h.Sum()
3281 data, _, err := cache.GetBytes(cache.Default(), key)
3282 if err == nil && len(data) > len(id) {
3283 stats := strings.Split(string(data[:len(data)-len(id)]), "\x00")
3284 if len(stats)%2 != 0 {
3285 goto Miss
3286 }
3287 for i := 0; i+2 <= len(stats); i++ {
3288 info, err := os.Stat(stats[i])
3289 if err != nil || statString(info) != stats[i+1] {
3290 goto Miss
3291 }
3292 }
3293 copy(id[:], data[len(data)-len(id):])
3294 return id, true
3295 Miss:
3296 }
3297
3298
3299
3300
3301
3302
3303 toolID, exe2, err := b.gccToolID(compiler, "c")
3304 if err != nil {
3305 return cache.ActionID{}, false
3306 }
3307
3308 exes := []string{exe, exe2}
3309 str.Uniq(&exes)
3310 fmt.Fprintf(h, "gccCompilerID %q %q\n", exes, toolID)
3311 id = h.Sum()
3312
3313 var buf bytes.Buffer
3314 for _, exe := range exes {
3315 if exe == "" {
3316 continue
3317 }
3318 info, err := os.Stat(exe)
3319 if err != nil {
3320 return cache.ActionID{}, false
3321 }
3322 buf.WriteString(exe)
3323 buf.WriteString("\x00")
3324 buf.WriteString(statString(info))
3325 buf.WriteString("\x00")
3326 }
3327 buf.Write(id[:])
3328
3329 cache.PutBytes(cache.Default(), key, buf.Bytes())
3330 if b.gccCompilerIDCache == nil {
3331 b.gccCompilerIDCache = make(map[string]cache.ActionID)
3332 }
3333 b.gccCompilerIDCache[compiler] = id
3334 return id, true
3335 }
3336
3337
3338 func (b *Builder) gccArchArgs() []string {
3339 switch cfg.Goarch {
3340 case "386":
3341 return []string{"-m32"}
3342 case "amd64":
3343 if cfg.Goos == "darwin" {
3344 return []string{"-arch", "x86_64", "-m64"}
3345 }
3346 return []string{"-m64"}
3347 case "arm64":
3348 if cfg.Goos == "darwin" {
3349 return []string{"-arch", "arm64"}
3350 }
3351 case "arm":
3352 return []string{"-marm"}
3353 case "s390x":
3354
3355 return []string{"-m64", "-march=z13"}
3356 case "mips64", "mips64le":
3357 args := []string{"-mabi=64"}
3358 if cfg.GOMIPS64 == "hardfloat" {
3359 return append(args, "-mhard-float")
3360 } else if cfg.GOMIPS64 == "softfloat" {
3361 return append(args, "-msoft-float")
3362 }
3363 case "mips", "mipsle":
3364 args := []string{"-mabi=32", "-march=mips32"}
3365 if cfg.GOMIPS == "hardfloat" {
3366 return append(args, "-mhard-float", "-mfp32", "-mno-odd-spreg")
3367 } else if cfg.GOMIPS == "softfloat" {
3368 return append(args, "-msoft-float")
3369 }
3370 case "loong64":
3371
3372
3373
3374
3375
3376 return []string{"-mabi=lp64d", "-mno-relax"}
3377 case "ppc64":
3378 if cfg.Goos == "aix" {
3379 return []string{"-maix64"}
3380 }
3381 }
3382 return nil
3383 }
3384
3385
3386
3387
3388
3389
3390
3391 func envList(key, def string) []string {
3392 v := cfg.Getenv(key)
3393 if v == "" {
3394 v = def
3395 }
3396 args, err := quoted.Split(v)
3397 if err != nil {
3398 panic(fmt.Sprintf("could not parse environment variable %s with value %q: %v", key, v, err))
3399 }
3400 return args
3401 }
3402
3403
3404 func (b *Builder) CFlags(p *load.Package) (cppflags, cflags, cxxflags, fflags, ldflags []string, err error) {
3405 if cppflags, err = buildFlags("CPPFLAGS", "", p.CgoCPPFLAGS, checkCompilerFlags); err != nil {
3406 return
3407 }
3408 if cflags, err = buildFlags("CFLAGS", DefaultCFlags, p.CgoCFLAGS, checkCompilerFlags); err != nil {
3409 return
3410 }
3411 if cxxflags, err = buildFlags("CXXFLAGS", DefaultCFlags, p.CgoCXXFLAGS, checkCompilerFlags); err != nil {
3412 return
3413 }
3414 if fflags, err = buildFlags("FFLAGS", DefaultCFlags, p.CgoFFLAGS, checkCompilerFlags); err != nil {
3415 return
3416 }
3417 if ldflags, err = buildFlags("LDFLAGS", DefaultCFlags, p.CgoLDFLAGS, checkLinkerFlags); err != nil {
3418 return
3419 }
3420 if p.Dir != "" && hasGCCSpecFlags(p.CgoLDFLAGS) {
3421 if err = checkLinkerSpecDir("#cgo LDFLAGS", p.Dir); err != nil {
3422 return
3423 }
3424 }
3425
3426 return
3427 }
3428
3429 func buildFlags(name, defaults string, fromPackage []string, check func(string, string, []string) error) ([]string, error) {
3430 if err := check(name, "#cgo "+name, fromPackage); err != nil {
3431 return nil, err
3432 }
3433 return slices.Concat(envList("CGO_"+name, defaults), fromPackage), nil
3434 }
3435
3436 var cgoRe = lazyregexp.New(`[/\\:]`)
3437
3438 type runCgoProvider struct {
3439 CFLAGS, CXXFLAGS, FFLAGS, LDFLAGS []string
3440 notCompatibleForInternalLinking bool
3441 nonGoOverlay map[string]string
3442 goFiles []string
3443 }
3444
3445 func (pr *runCgoProvider) cflags() []string {
3446 return pr.CFLAGS
3447 }
3448
3449 func (pr *runCgoProvider) cxxflags() []string {
3450 return pr.CXXFLAGS
3451 }
3452
3453 func (pr *runCgoProvider) fflags() []string {
3454 return pr.FFLAGS
3455 }
3456
3457 func (pr *runCgoProvider) ldflags() []string {
3458 return pr.LDFLAGS
3459 }
3460
3461 func mustGetCoverInfo(a *Action) *coverProvider {
3462 for _, dep := range a.Deps {
3463 if dep.Mode == "cover" {
3464 return dep.Provider.(*coverProvider)
3465 }
3466 }
3467 base.Fatalf("internal error: cover provider not found")
3468 panic("unreachable")
3469 }
3470
3471 func (b *Builder) runCgo(_ context.Context, a *Action) error {
3472 p := a.Package
3473 sh := b.Shell(a)
3474 objdir := a.Objdir
3475
3476 if err := sh.Mkdir(objdir); err != nil {
3477 return err
3478 }
3479
3480 nonGoFileLists := [][]string{p.CFiles, p.SFiles, p.CXXFiles, p.HFiles, p.FFiles}
3481 if err := b.computeNonGoOverlay(a, p, sh, objdir, nonGoFileLists); err != nil {
3482 return err
3483 }
3484
3485 a.actionID = b.cgoRunActionID(a)
3486 if pr, err := b.loadCachedRunCgoOutputs(a); err == nil {
3487 pr.nonGoOverlay = a.nonGoOverlay
3488 a.Provider = pr
3489 return nil
3490 }
3491
3492 cgofiles := slices.Clip(p.CgoFiles)
3493 if a.Package.Internal.Cover.Mode != "" {
3494 cp := mustGetCoverInfo(a)
3495 cgofiles = cp.cgoSources
3496 }
3497
3498 pcCFLAGS, pcLDFLAGS, err := b.getPkgConfigFlags(a, p)
3499 if err != nil {
3500 return err
3501 }
3502
3503
3504
3505
3506
3507
3508
3509 if p.UsesSwig() {
3510 if err := b.swig(a, objdir, pcCFLAGS); err != nil {
3511 return err
3512 }
3513 outGo, _, _ := b.swigOutputs(p, objdir)
3514 cgofiles = append(cgofiles, outGo...)
3515 }
3516
3517 cgoExe := base.Tool("cgo")
3518 cgofiles = mkAbsFiles(p.Dir, cgofiles)
3519
3520 cgoCPPFLAGS, cgoCFLAGS, cgoCXXFLAGS, cgoFFLAGS, cgoLDFLAGS, err := b.CFlags(p)
3521 if err != nil {
3522 return err
3523 }
3524
3525 cgoCPPFLAGS = append(cgoCPPFLAGS, pcCFLAGS...)
3526 cgoLDFLAGS = append(cgoLDFLAGS, pcLDFLAGS...)
3527
3528 if len(p.MFiles) > 0 {
3529 cgoLDFLAGS = append(cgoLDFLAGS, "-lobjc")
3530 }
3531
3532
3533
3534
3535 if len(p.FFiles) > 0 {
3536 fc := cfg.Getenv("FC")
3537 if fc == "" {
3538 fc = "gfortran"
3539 }
3540 if strings.Contains(fc, "gfortran") {
3541 cgoLDFLAGS = append(cgoLDFLAGS, "-lgfortran")
3542 }
3543 }
3544
3545
3546
3547
3548
3549
3550
3551
3552
3553
3554
3555
3556
3557
3558
3559
3560 flagSources := []string{"CGO_CPPFLAGS", "CGO_CFLAGS", "CGO_CXXFLAGS", "CGO_FFLAGS"}
3561 flagLists := [][]string{cgoCPPFLAGS, cgoCFLAGS, cgoCXXFLAGS, cgoFFLAGS}
3562 notCompatibleWithInternalLinking := flagsNotCompatibleWithInternalLinking(flagSources, flagLists)
3563 if !notCompatibleWithInternalLinking {
3564 if err := checkLinkerFlagsForInternalLink("CGO_LDFLAGS", "CGO_LDFLAGS", cgoLDFLAGS); err != nil {
3565 notCompatibleWithInternalLinking = true
3566 }
3567 }
3568
3569 if cfg.BuildMSan {
3570 cgoCFLAGS = append([]string{"-fsanitize=memory"}, cgoCFLAGS...)
3571 cgoLDFLAGS = append([]string{"-fsanitize=memory"}, cgoLDFLAGS...)
3572 }
3573 if cfg.BuildASan {
3574 cgoCFLAGS = append([]string{"-fsanitize=address"}, cgoCFLAGS...)
3575 cgoLDFLAGS = append([]string{"-fsanitize=address"}, cgoLDFLAGS...)
3576 }
3577
3578
3579
3580 cgoCPPFLAGS = append(cgoCPPFLAGS, "-I", objdir)
3581
3582
3583
3584 gofiles := []string{objdir + "_cgo_gotypes.go"}
3585 cfiles := []string{objdir + "_cgo_export.c"}
3586 for _, fn := range cgofiles {
3587 f := strings.TrimSuffix(filepath.Base(fn), ".go")
3588 gofiles = append(gofiles, objdir+f+".cgo1.go")
3589 cfiles = append(cfiles, objdir+f+".cgo2.c")
3590 }
3591
3592
3593
3594 cgoflags := []string{}
3595 if p.Standard && p.ImportPath == "runtime/cgo" {
3596 cgoflags = append(cgoflags, "-import_runtime_cgo=false")
3597 }
3598 if p.Standard && (p.ImportPath == "runtime/race" || p.ImportPath == "runtime/msan" || p.ImportPath == "runtime/cgo" || p.ImportPath == "runtime/asan") {
3599 cgoflags = append(cgoflags, "-import_syscall=false")
3600 }
3601
3602
3603
3604
3605
3606
3607
3608
3609
3610
3611
3612 cgoenv := b.cCompilerEnv()
3613 cgoenv = append(cgoenv, cfgChangedEnv...)
3614 var ldflagsOption []string
3615 if len(cgoLDFLAGS) > 0 {
3616 flags := make([]string, len(cgoLDFLAGS))
3617 for i, f := range cgoLDFLAGS {
3618 flags[i] = strconv.Quote(f)
3619 }
3620 ldflagsOption = []string{"-ldflags=" + strings.Join(flags, " ")}
3621
3622
3623 cgoenv = append(cgoenv, "CGO_LDFLAGS=")
3624 }
3625
3626 if cfg.BuildToolchainName == "gccgo" {
3627 if b.gccSupportsFlag([]string{BuildToolchain.compiler()}, "-fsplit-stack") {
3628 cgoCFLAGS = append(cgoCFLAGS, "-fsplit-stack")
3629 }
3630 cgoflags = append(cgoflags, "-gccgo")
3631 if pkgpath := gccgoPkgpath(p); pkgpath != "" {
3632 cgoflags = append(cgoflags, "-gccgopkgpath="+pkgpath)
3633 }
3634 if !BuildToolchain.(gccgoToolchain).supportsCgoIncomplete(b, a) {
3635 cgoflags = append(cgoflags, "-gccgo_define_cgoincomplete")
3636 }
3637 }
3638
3639 switch cfg.BuildBuildmode {
3640 case "c-archive", "c-shared":
3641
3642
3643
3644 cgoflags = append(cgoflags, "-exportheader="+objdir+"_cgo_install.h")
3645 }
3646
3647
3648
3649 var trimpath []string
3650 for i := range cgofiles {
3651 path := mkAbs(p.Dir, cgofiles[i])
3652 if fsys.Replaced(path) {
3653 actual := fsys.Actual(path)
3654 cgofiles[i] = actual
3655 trimpath = append(trimpath, actual+"=>"+path)
3656 }
3657 }
3658 if len(trimpath) > 0 {
3659 cgoflags = append(cgoflags, "-trimpath", strings.Join(trimpath, ";"))
3660 }
3661
3662 if err := sh.run(p.Dir, p.ImportPath, cgoenv, cfg.BuildToolexec, cgoExe, "-objdir", objdir, "-importpath", p.ImportPath, cgoflags, ldflagsOption, "--", cgoCPPFLAGS, cgoCFLAGS, cgofiles); err != nil {
3663 return err
3664 }
3665
3666 a.Provider = &runCgoProvider{
3667 CFLAGS: slices.Concat(cgoCPPFLAGS, cgoCFLAGS),
3668 CXXFLAGS: slices.Concat(cgoCPPFLAGS, cgoCXXFLAGS),
3669 FFLAGS: slices.Concat(cgoCPPFLAGS, cgoFFLAGS),
3670 LDFLAGS: cgoLDFLAGS,
3671 notCompatibleForInternalLinking: notCompatibleWithInternalLinking,
3672 nonGoOverlay: a.nonGoOverlay,
3673 goFiles: gofiles,
3674 }
3675
3676 if !cfg.BuildN {
3677 pr := a.Provider.(*runCgoProvider)
3678 if err := b.cacheRunCgoOutputs(a, pr); err != nil {
3679 return err
3680 }
3681 }
3682
3683 return nil
3684 }
3685
3686 func (b *Builder) processCgoOutputs(a *Action, runCgoProvider *runCgoProvider, cgoExe, objdir string) (outGo, outObj []string, err error) {
3687 outGo = slices.Clip(runCgoProvider.goFiles)
3688
3689
3690
3691
3692
3693
3694
3695
3696 sh := b.Shell(a)
3697
3698
3699
3700 if runCgoProvider.notCompatibleForInternalLinking {
3701 tokenFile := objdir + "preferlinkext"
3702 if err := sh.writeFile(tokenFile, nil); err != nil {
3703 return nil, nil, err
3704 }
3705 outObj = append(outObj, tokenFile)
3706 }
3707
3708 var collectAction *Action
3709 for _, dep := range a.Deps {
3710 if dep.Mode == "collect cgo" {
3711 collectAction = dep
3712 }
3713 }
3714 if collectAction == nil {
3715 base.Fatalf("internal error: no cgo collect action")
3716 }
3717 for _, dep := range collectAction.Deps {
3718 outObj = append(outObj, dep.Target)
3719 }
3720
3721 switch cfg.BuildToolchainName {
3722 case "gc":
3723 importGo := objdir + "_cgo_import.go"
3724 dynOutGo, dynOutObj, err := b.dynimport(a, objdir, importGo, cgoExe, runCgoProvider.CFLAGS, runCgoProvider.LDFLAGS, outObj)
3725 if err != nil {
3726 return nil, nil, err
3727 }
3728 if dynOutGo != "" {
3729 outGo = append(outGo, dynOutGo)
3730 }
3731 if dynOutObj != "" {
3732 outObj = append(outObj, dynOutObj)
3733 }
3734
3735 case "gccgo":
3736 defunC := objdir + "_cgo_defun.c"
3737 defunObj := objdir + "_cgo_defun.o"
3738 if err := BuildToolchain.cc(b, a, defunObj, defunC); err != nil {
3739 return nil, nil, err
3740 }
3741 outObj = append(outObj, defunObj)
3742
3743 default:
3744 noCompiler()
3745 }
3746
3747
3748
3749
3750
3751
3752 if cfg.BuildToolchainName == "gc" && !cfg.BuildN {
3753 var flags []string
3754 for _, f := range outGo {
3755 if !strings.HasPrefix(filepath.Base(f), "_cgo_") {
3756 continue
3757 }
3758
3759 src, err := os.ReadFile(f)
3760 if err != nil {
3761 return nil, nil, err
3762 }
3763
3764 const cgoLdflag = "//go:cgo_ldflag"
3765 idx := bytes.Index(src, []byte(cgoLdflag))
3766 for idx >= 0 {
3767
3768
3769 start := bytes.LastIndex(src[:idx], []byte("\n"))
3770 if start == -1 {
3771 start = 0
3772 }
3773
3774
3775 end := bytes.Index(src[idx:], []byte("\n"))
3776 if end == -1 {
3777 end = len(src)
3778 } else {
3779 end += idx
3780 }
3781
3782
3783
3784
3785
3786 commentStart := bytes.Index(src[start:], []byte("//"))
3787 commentStart += start
3788
3789
3790 if bytes.HasPrefix(src[commentStart:], []byte(cgoLdflag)) {
3791
3792
3793 flag := string(src[idx+len(cgoLdflag) : end])
3794 flag = strings.TrimSpace(flag)
3795 flag, err = strconv.Unquote(flag)
3796 if err != nil {
3797 return nil, nil, err
3798 }
3799 flags = append(flags, flag)
3800 }
3801 src = src[end:]
3802 idx = bytes.Index(src, []byte(cgoLdflag))
3803 }
3804 }
3805
3806
3807 if n := len(runCgoProvider.LDFLAGS); n > 0 {
3808 outer:
3809 for i := 0; i+n <= len(flags); i++ {
3810 for j, f := range runCgoProvider.LDFLAGS {
3811 if f != flags[i+j] {
3812 continue outer
3813 }
3814 }
3815 flags = append(flags[:i], flags[i+n:]...)
3816 break
3817 }
3818 }
3819
3820 if err := checkLinkerFlags("LDFLAGS", "go:cgo_ldflag", flags); err != nil {
3821 return nil, nil, err
3822 }
3823 }
3824
3825 return outGo, outObj, nil
3826 }
3827
3828
3829
3830
3831
3832
3833
3834
3835 func flagsNotCompatibleWithInternalLinking(sourceList []string, flagListList [][]string) bool {
3836 for i := range sourceList {
3837 sn := sourceList[i]
3838 fll := flagListList[i]
3839 if err := checkCompilerFlagsForInternalLink(sn, sn, fll); err != nil {
3840 return true
3841 }
3842 }
3843 return false
3844 }
3845
3846
3847
3848
3849
3850
3851 func (b *Builder) dynimport(a *Action, objdir, importGo, cgoExe string, cflags, cgoLDFLAGS, outObj []string) (dynOutGo, dynOutObj string, err error) {
3852 p := a.Package
3853 sh := b.Shell(a)
3854
3855 cfile := objdir + "_cgo_main.c"
3856 ofile := objdir + "_cgo_main.o"
3857 if err := b.gcc(a, objdir, ofile, cflags, cfile); err != nil {
3858 return "", "", err
3859 }
3860
3861
3862 var syso []string
3863 seen := make(map[*Action]bool)
3864 var gatherSyso func(*Action)
3865 gatherSyso = func(a1 *Action) {
3866 if seen[a1] {
3867 return
3868 }
3869 seen[a1] = true
3870 if p1 := a1.Package; p1 != nil {
3871 syso = append(syso, mkAbsFiles(p1.Dir, p1.SysoFiles)...)
3872 }
3873 for _, a2 := range a1.Deps {
3874 gatherSyso(a2)
3875 }
3876 }
3877 gatherSyso(a)
3878 sort.Strings(syso)
3879 str.Uniq(&syso)
3880 if !cfg.BuildN {
3881 for _, f := range syso {
3882 if err := checkLinkerInputFile(".syso", f); err != nil {
3883 return "", "", err
3884 }
3885 }
3886 }
3887 linkobj := str.StringList(ofile, outObj, syso)
3888 dynobj := objdir + "_cgo_.o"
3889
3890 ldflags := cgoLDFLAGS
3891 if (cfg.Goarch == "arm" && cfg.Goos == "linux") || cfg.Goos == "android" {
3892 if !slices.Contains(ldflags, "-no-pie") {
3893
3894
3895 ldflags = append(ldflags, "-pie")
3896 }
3897 if slices.Contains(ldflags, "-pie") && slices.Contains(ldflags, "-static") {
3898
3899
3900 n := make([]string, 0, len(ldflags)-1)
3901 for _, flag := range ldflags {
3902 if flag != "-static" {
3903 n = append(n, flag)
3904 }
3905 }
3906 ldflags = n
3907 }
3908 }
3909 if err := b.gccld(a, objdir, dynobj, ldflags, linkobj); err != nil {
3910
3911
3912
3913
3914
3915
3916 fail := objdir + "dynimportfail"
3917 if err := sh.writeFile(fail, nil); err != nil {
3918 return "", "", err
3919 }
3920 return "", fail, nil
3921 }
3922
3923
3924 var cgoflags []string
3925 if p.Standard && p.ImportPath == "runtime/cgo" {
3926 cgoflags = []string{"-dynlinker"}
3927 }
3928 err = sh.run(base.Cwd(), p.ImportPath, b.cCompilerEnv(), cfg.BuildToolexec, cgoExe, "-dynpackage", p.Name, "-dynimport", dynobj, "-dynout", importGo, cgoflags)
3929 if err != nil {
3930 return "", "", err
3931 }
3932 return importGo, "", nil
3933 }
3934
3935
3936
3937
3938 func (b *Builder) swig(a *Action, objdir string, pcCFLAGS []string) error {
3939 p := a.Package
3940
3941 if err := b.swigVersionCheck(); err != nil {
3942 return err
3943 }
3944
3945 intgosize, err := b.swigIntSize(objdir)
3946 if err != nil {
3947 return err
3948 }
3949
3950 for _, f := range p.SwigFiles {
3951 if err := b.swigOne(a, f, objdir, pcCFLAGS, false, intgosize); err != nil {
3952 return err
3953 }
3954 }
3955 for _, f := range p.SwigCXXFiles {
3956 if err := b.swigOne(a, f, objdir, pcCFLAGS, true, intgosize); err != nil {
3957 return err
3958 }
3959 }
3960 return nil
3961 }
3962
3963 func (b *Builder) swigOutputs(p *load.Package, objdir string) (outGo, outC, outCXX []string) {
3964 for _, f := range p.SwigFiles {
3965 goFile, cFile := swigOneOutputs(f, objdir, false)
3966 outGo = append(outGo, goFile)
3967 outC = append(outC, cFile)
3968 }
3969 for _, f := range p.SwigCXXFiles {
3970 goFile, cxxFile := swigOneOutputs(f, objdir, true)
3971 outGo = append(outGo, goFile)
3972 outCXX = append(outCXX, cxxFile)
3973 }
3974 return outGo, outC, outCXX
3975 }
3976
3977
3978 var (
3979 swigCheckOnce sync.Once
3980 swigCheck error
3981 )
3982
3983 func (b *Builder) swigDoVersionCheck() error {
3984 sh := b.BackgroundShell()
3985 out, err := sh.runOut(".", nil, "swig", "-version")
3986 if err != nil {
3987 return err
3988 }
3989 re := regexp.MustCompile(`[vV]ersion +(\d+)([.]\d+)?([.]\d+)?`)
3990 matches := re.FindSubmatch(out)
3991 if matches == nil {
3992
3993 return nil
3994 }
3995
3996 major, err := strconv.Atoi(string(matches[1]))
3997 if err != nil {
3998
3999 return nil
4000 }
4001 const errmsg = "must have SWIG version >= 3.0.6"
4002 if major < 3 {
4003 return errors.New(errmsg)
4004 }
4005 if major > 3 {
4006
4007 return nil
4008 }
4009
4010
4011 if len(matches[2]) > 0 {
4012 minor, err := strconv.Atoi(string(matches[2][1:]))
4013 if err != nil {
4014 return nil
4015 }
4016 if minor > 0 {
4017
4018 return nil
4019 }
4020 }
4021
4022
4023 if len(matches[3]) > 0 {
4024 patch, err := strconv.Atoi(string(matches[3][1:]))
4025 if err != nil {
4026 return nil
4027 }
4028 if patch < 6 {
4029
4030 return errors.New(errmsg)
4031 }
4032 }
4033
4034 return nil
4035 }
4036
4037 func (b *Builder) swigVersionCheck() error {
4038 swigCheckOnce.Do(func() {
4039 swigCheck = b.swigDoVersionCheck()
4040 })
4041 return swigCheck
4042 }
4043
4044
4045 var (
4046 swigIntSizeOnce sync.Once
4047 swigIntSize string
4048 swigIntSizeError error
4049 )
4050
4051
4052 const swigIntSizeCode = `
4053 package main
4054 const i int = 1 << 32
4055 `
4056
4057
4058
4059 func (b *Builder) swigDoIntSize(objdir string) (intsize string, err error) {
4060 if cfg.BuildN {
4061 return "$INTBITS", nil
4062 }
4063 src := filepath.Join(b.WorkDir, "swig_intsize.go")
4064 if err = os.WriteFile(src, []byte(swigIntSizeCode), 0666); err != nil {
4065 return
4066 }
4067 srcs := []string{src}
4068
4069 p := load.GoFilesPackage(modload.NewLoader(), context.TODO(), load.PackageOpts{}, srcs)
4070
4071 if _, _, _, e := BuildToolchain.gc(b, &Action{Mode: "swigDoIntSize", Package: p, Objdir: objdir}, "", nil, nil, "", false, "", "", srcs); e != nil {
4072 return "32", nil
4073 }
4074 return "64", nil
4075 }
4076
4077
4078
4079 func (b *Builder) swigIntSize(objdir string) (intsize string, err error) {
4080 swigIntSizeOnce.Do(func() {
4081 swigIntSize, swigIntSizeError = b.swigDoIntSize(objdir)
4082 })
4083 return swigIntSize, swigIntSizeError
4084 }
4085
4086
4087 func (b *Builder) swigOne(a *Action, file, objdir string, pcCFLAGS []string, cxx bool, intgosize string) error {
4088 if strings.HasPrefix(file, "cgo") {
4089 return errors.New("SWIG file must not use prefix 'cgo'")
4090 }
4091
4092 p := a.Package
4093 sh := b.Shell(a)
4094
4095 cgoCPPFLAGS, cgoCFLAGS, cgoCXXFLAGS, _, _, err := b.CFlags(p)
4096 if err != nil {
4097 return err
4098 }
4099
4100 var cflags []string
4101 if cxx {
4102 cflags = slices.Concat(cgoCPPFLAGS, pcCFLAGS, cgoCXXFLAGS)
4103 } else {
4104 cflags = slices.Concat(cgoCPPFLAGS, pcCFLAGS, cgoCFLAGS)
4105 }
4106
4107 base := swigBase(file, cxx)
4108 newGoFile, outC := swigOneOutputs(file, objdir, cxx)
4109
4110 gccgo := cfg.BuildToolchainName == "gccgo"
4111
4112
4113 args := []string{
4114 "-go",
4115 "-cgo",
4116 "-intgosize", intgosize,
4117 "-module", base,
4118 "-o", outC,
4119 "-outdir", objdir,
4120 }
4121
4122 for _, f := range cflags {
4123 if len(f) > 3 && f[:2] == "-I" {
4124 args = append(args, f)
4125 }
4126 }
4127
4128 if gccgo {
4129 args = append(args, "-gccgo")
4130 if pkgpath := gccgoPkgpath(p); pkgpath != "" {
4131 args = append(args, "-go-pkgpath", pkgpath)
4132 }
4133 }
4134 if cxx {
4135 args = append(args, "-c++")
4136 }
4137
4138 out, err := sh.runOut(p.Dir, nil, "swig", args, file)
4139 if err != nil && (bytes.Contains(out, []byte("-intgosize")) || bytes.Contains(out, []byte("-cgo"))) {
4140 return errors.New("must have SWIG version >= 3.0.6")
4141 }
4142 if err := sh.reportCmd("", "", out, err); err != nil {
4143 return err
4144 }
4145
4146
4147
4148
4149
4150
4151
4152
4153
4154 goFile := objdir + base + ".go"
4155 if cfg.BuildX || cfg.BuildN {
4156 sh.ShowCmd("", "mv %s %s", goFile, newGoFile)
4157 }
4158 if !cfg.BuildN {
4159 if err := os.Rename(goFile, newGoFile); err != nil {
4160 return err
4161 }
4162 }
4163
4164 return nil
4165 }
4166
4167 func swigBase(file string, cxx bool) string {
4168 n := 5
4169 if cxx {
4170 n = 8
4171 }
4172 return file[:len(file)-n]
4173 }
4174
4175 func swigOneOutputs(file, objdir string, cxx bool) (outGo, outC string) {
4176 base := swigBase(file, cxx)
4177 gccBase := base + "_wrap."
4178 gccExt := "c"
4179 if cxx {
4180 gccExt = "cxx"
4181 }
4182
4183 newGoFile := objdir + "_" + base + "_swig.go"
4184 cFile := objdir + gccBase + gccExt
4185 return newGoFile, cFile
4186 }
4187
4188
4189
4190
4191
4192
4193
4194
4195
4196
4197
4198 func (b *Builder) disableBuildID(ldflags []string) []string {
4199 switch cfg.Goos {
4200 case "android", "dragonfly", "linux", "netbsd":
4201 ldflags = append(ldflags, "-Wl,--build-id=none")
4202 }
4203 return ldflags
4204 }
4205
4206
4207
4208
4209 func mkAbsFiles(dir string, files []string) []string {
4210 abs := make([]string, len(files))
4211 for i, f := range files {
4212 if !filepath.IsAbs(f) {
4213 f = filepath.Join(dir, f)
4214 }
4215 abs[i] = f
4216 }
4217 return abs
4218 }
4219
4220
4221
4222
4223
4224
4225
4226
4227
4228 func trimObjdir(a *Action, files []string) []string {
4229 for i, f := range files {
4230 if rel, ok := strings.CutPrefix(f, a.Objdir); ok && a.Objdir != "" {
4231 files[i] = rel
4232 }
4233 }
4234 return files
4235 }
4236
4237
4238 func actualFiles(files []string) []string {
4239 a := make([]string, len(files))
4240 for i, f := range files {
4241 a[i] = fsys.Actual(f)
4242 }
4243 return a
4244 }
4245
4246
4247
4248
4249
4250
4251
4252
4253 func passLongArgsInResponseFiles(cmd *exec.Cmd) (cleanup func()) {
4254 cleanup = func() {}
4255
4256 var argLen int
4257 for _, arg := range cmd.Args {
4258 argLen += len(arg)
4259 }
4260
4261
4262
4263 if !useResponseFile(cmd.Path, argLen) {
4264 return
4265 }
4266
4267 tf, err := os.CreateTemp("", "args")
4268 if err != nil {
4269 log.Fatalf("error writing long arguments to response file: %v", err)
4270 }
4271 cleanup = func() { os.Remove(tf.Name()) }
4272 var buf bytes.Buffer
4273 for _, arg := range cmd.Args[1:] {
4274 fmt.Fprintf(&buf, "%s\n", encodeArg(arg))
4275 }
4276 if _, err := tf.Write(buf.Bytes()); err != nil {
4277 tf.Close()
4278 cleanup()
4279 log.Fatalf("error writing long arguments to response file: %v", err)
4280 }
4281 if err := tf.Close(); err != nil {
4282 cleanup()
4283 log.Fatalf("error writing long arguments to response file: %v", err)
4284 }
4285 cmd.Args = []string{cmd.Args[0], "@" + tf.Name()}
4286 return cleanup
4287 }
4288
4289 func useResponseFile(path string, argLen int) bool {
4290
4291
4292
4293 prog := strings.TrimSuffix(filepath.Base(path), ".exe")
4294 switch prog {
4295 case "compile", "link", "cgo", "asm", "cover", "pack":
4296 default:
4297 return false
4298 }
4299
4300 if argLen > sys.ExecArgLengthLimit {
4301 return true
4302 }
4303
4304
4305
4306 isBuilder := os.Getenv("GO_BUILDER_NAME") != ""
4307 if isBuilder && rand.Intn(10) == 0 {
4308 return true
4309 }
4310
4311 return false
4312 }
4313
4314
4315
4316 func encodeArg(arg string) string {
4317
4318 if arg == "" {
4319 return `""`
4320 }
4321
4322 if !strings.ContainsAny(arg, " \t\n\r'\"\\$`") {
4323 return arg
4324 }
4325
4326
4327 var b strings.Builder
4328 b.WriteByte('"')
4329 for _, r := range arg {
4330 switch r {
4331 case '\\':
4332 b.WriteString(`\\`)
4333 case '"':
4334 b.WriteString(`\"`)
4335 case '$':
4336 b.WriteString(`\$`)
4337 case '`':
4338 b.WriteString("\\`")
4339 default:
4340 b.WriteRune(r)
4341 }
4342 }
4343 b.WriteByte('"')
4344 return b.String()
4345 }
4346
View as plain text