cmd/go: run cgo and cgo compiles in their own actions

This change splits package builds further into even more actions.

Between the cache action (and cover action, if present) and the actual
build action we insert three layers of actions:

              Check Cache Action
              |      |
              |      V
              | Run Cover Action (if cover requested)
              |      |
              |      V
 New Layer 1  | Run Cgo Action (if package is built with cgo)
              |      | | | (multiple arrows representing fan-out to
              |      V V V  multiple actions)
 New Layer 2  | gcc Compile Action for each C/C++/S/F/M file (if cgo)
              |      |/    (arrow represeting fan-in to single action)
              |      V
 New Layer 3  | Cgo collect action (if cgo)
              |      |
              \      V
                Build action

The first run cgo action takes the input source files and runs cgo on
them to produce the cgo-processed go files, which are given to the
compiler, and to produce additional C files to compile and headers to
use in the following compilations. The action also takes care of running
SWIG before running cgo if there are swig files. This will produce
additional cgo sources that are inputs to cgo.

The run cgo action action fans out to multiple actions to do each of the
C/C++/Obj-C/assembly/Fortran compilations for the non-Go files in the
package, as well as those produced as outputs by the cgo command
invocation.

These actions then join into a single noop "collect" action which
primarily exists so that we don't pollute the build action's
dependencies with a bunch of non-go compile actions. (The build action
expects its dependencies to mostly be other build actions).

All of this work in the new actions was previously being done in the
build action itself. There's still a remnant of the original cgo logic
left in the build action to run the cgo command with -dynimport to
produce a go file to be built with the rest of the package, and do some
checks.

Most of this CL consists of moving code around. Just like the previous
CL breaking out the coverage logic into a separate action, we don't
cache the outputs of the cgo actions, and just treat all the actions
used to build a single package as one cacheable unit. This makes things
a bit simpler. If we decide in a future CL to cache the outputs
separately, we could remove the dependency on the cover action on the
check cache action (which in turn depends on all the package's
dependencies) and could start non-go compilation pretty much as early as
we want in the build.

The 'cgoAction' function in action.go takes care of creating the layers
of cgo action dependencies, which are inserted as dependencies of the
build action. It's mostly straightforward, except for the fact that we
need to tell each non-go compile action which non-go file to compile, so
we need to compute the names of the generated files. (Alternatively we
could give each action a number and have it build the nth file produced
by the run cgo action, but that seems even more complicated). The actors
produced to run the action logic are pretty light wrappers around the
execution logic in exec.go.

In the 'build' function in exec.go, most of the new code mainly checks
for the information from the cgo actions to use instead of running it,
and then passes it to the processCgoOutputs function. The only other
weird thing in the build functian is that we we call the logic to
compute the nonGoOverlay separately just for the C files that are being
built with gccgo. We compute the overlay for the non-go files used in a
cgo build in the run cgo action.

The 'cgo' function that previously ran the cgo logic for the build has
now been split into three: the first half, which runs cgo is now in the
runCgo function, the center part, which compiles the non-go files is now
partly in creating the invididual non-go compile actions, as well as the
cgoCompileActor's Act function. And the final part, which runs
cgo -dynimport is now in processCgoOutputs. These parts communicate with
each other through the providers that are set on the cgo actions.

One further improvement we can make to this change in the future is to
compile the dynimport file separately from the build action: its output
is only needed by the linker. This would remove any dependencies from
dependent packages' build actions on the cgo compile actions, allowing
more flexibility for scheduling actions.

Fixes golang#9887

Change-Id: Ie3c70bbf985148ba73094cddfc78c39dc6faad6e
Reviewed-on: https://go-review.googlesource.com/c/go/+/694475
Reviewed-by: Michael Pratt <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Michael Matloob <[email protected]>

Author: matloob

src/cmd/go/internal/work/action.go

@@ -19,6 +19,7 @@ import (
 	"internal/platform"
 	"os"
 	"path/filepath"
+	"slices"
 	"strings"
 	"sync"
 	"time"
@@ -578,6 +579,47 @@ func (ca *coverActor) Act(b *Builder, ctx context.Context, a *Action) error {
 	return nil
 }
 
+// runCgoActor implements the Actor interface for running the cgo command for the package.
+type runCgoActor struct {
+}
+
+func (c runCgoActor) Act(b *Builder, ctx context.Context, a *Action) error {
+	var cacheProvider *checkCacheProvider
+	for _, a1 := range a.Deps {
+		if pr, ok := a1.Provider.(*checkCacheProvider); ok {
+			cacheProvider = pr
+			break
+		}
+	}
+	need := cacheProvider.need
+	need &^= needCovMetaFile // handled by cover action
+	if need == 0 {
+		return nil
+	}
+	return b.runCgo(ctx, a)
+}
+
+type cgoCompileActor struct {
+	file string
+
+	compileFunc  func(*Action, string, string, []string, string) error
+	getFlagsFunc func(*runCgoProvider) []string
+
+	flags *[]string
+}
+
+func (c cgoCompileActor) Act(b *Builder, ctx context.Context, a *Action) error {
+	pr, ok := a.Deps[0].Provider.(*runCgoProvider)
+	if !ok {
+		return nil // cgo was not needed. do nothing.
+	}
+	a.nonGoOverlay = pr.nonGoOverlay
+	buildAction := a.triggers[0].triggers[0] // cgo compile -> cgo collect -> build
+
+	a.actionID = cache.Subkey(buildAction.actionID, "cgo compile "+c.file) // buildAction's action id was computed by the check cache action.
+	return c.compileFunc(a, a.Objdir, a.Target, c.getFlagsFunc(pr), c.file)
+}
+
 // CompileAction returns the action for compiling and possibly installing
 // (according to mode) the given package. The resulting action is only
 // for building packages (archives), never for linking executables.
@@ -677,6 +719,17 @@ func (b *Builder) CompileAction(mode, depMode BuildMode, p *load.Package) *Actio
 			a.Deps = append(a.Deps, coverAction)
 		}
 
+		// Create actions to run swig and cgo if needed. These actions always run in the
+		// same go build invocation as the build action and their actions are not cached
+		// separately, so they can use the same objdir.
+		if p.UsesCgo() || p.UsesSwig() {
+			deps := []*Action{cacheAction}
+			if coverAction != nil {
+				deps = append(deps, coverAction)
+			}
+			a.Deps = append(a.Deps, b.cgoAction(p, a.Objdir, deps, coverAction != nil))
+		}
+
 		return a
 	})
 
@@ -701,6 +754,114 @@ func (b *Builder) CompileAction(mode, depMode BuildMode, p *load.Package) *Actio
 	return a
 }
 
+func (b *Builder) cgoAction(p *load.Package, objdir string, deps []*Action, hasCover bool) *Action {
+	cgoCollectAction := b.cacheAction("cgo collect", p, func() *Action {
+		// Run cgo
+		runCgo := b.cacheAction("cgo run", p, func() *Action {
+			return &Action{
+				Package: p,
+				Mode:    "cgo run",
+				Actor:   &runCgoActor{},
+				Objdir:  objdir,
+				Deps:    deps,
+			}
+		})
+
+		// Determine which files swig will produce in the cgo run action. We'll need to create
+		// actions to compile the C and C++ files produced by swig, as well as the C file
+		// produced by cgo processing swig's Go file outputs.
+		swigGo, swigC, swigCXX := b.swigOutputs(p, objdir)
+
+		oseq := 0
+		nextOfile := func() string {
+			oseq++
+			return objdir + fmt.Sprintf("_x%03d.o", oseq)
+		}
+		compileAction := func(file string, getFlagsFunc func(*runCgoProvider) []string, compileFunc func(*Action, string, string, []string, string) error) *Action {
+			mode := "cgo compile " + file
+			return b.cacheAction(mode, p, func() *Action {
+				return &Action{
+					Package: p,
+					Mode:    mode,
+					Actor:   &cgoCompileActor{file: file, getFlagsFunc: getFlagsFunc, compileFunc: compileFunc},
+					Deps:    []*Action{runCgo},
+					Objdir:  objdir,
+					Target:  nextOfile(),
+				}
+			})
+		}
+
+		var collectDeps []*Action
+
+		// Add compile actions for C files generated by cgo.
+		cgoFiles := p.CgoFiles
+		if hasCover {
+			cgoFiles = slices.Clone(cgoFiles)
+			for i := range cgoFiles {
+				cgoFiles[i] = strings.TrimSuffix(cgoFiles[i], ".go") + ".cover.go"
+			}
+		}
+		cfiles := []string{"_cgo_export.c"}
+		for _, fn := range slices.Concat(cgoFiles, swigGo) {
+			cfiles = append(cfiles, strings.TrimSuffix(filepath.Base(fn), ".go")+".cgo2.c")
+		}
+		for _, f := range cfiles {
+			collectDeps = append(collectDeps, compileAction(objdir+f, (*runCgoProvider).cflags, b.gcc))
+		}
+
+		// Add compile actions for S files.
+		var sfiles []string
+		// In a package using cgo, cgo compiles the C, C++ and assembly files with gcc.
+		// There is one exception: runtime/cgo's job is to bridge the
+		// cgo and non-cgo worlds, so it necessarily has files in both.
+		// In that case gcc only gets the gcc_* files.
+		if p.Standard && p.ImportPath == "runtime/cgo" {
+			for _, f := range p.SFiles {
+				if strings.HasPrefix(f, "gcc_") {
+					sfiles = append(sfiles, f)
+				}
+			}
+		} else {
+			sfiles = p.SFiles
+		}
+		for _, f := range sfiles {
+			collectDeps = append(collectDeps, compileAction(f, (*runCgoProvider).cflags, b.gas))
+		}
+
+		// Add compile actions for C files in the package, M files, and those generated by swig.
+		for _, f := range slices.Concat(p.CFiles, p.MFiles, swigC) {
+			collectDeps = append(collectDeps, compileAction(f, (*runCgoProvider).cflags, b.gcc))
+		}
+
+		// Add compile actions for C++ files in the package, and those generated by swig.
+		for _, f := range slices.Concat(p.CXXFiles, swigCXX) {
+			collectDeps = append(collectDeps, compileAction(f, (*runCgoProvider).cxxflags, b.gxx))
+		}
+
+		// Add compile actions for Fortran files in the package.
+		for _, f := range p.FFiles {
+			collectDeps = append(collectDeps, compileAction(f, (*runCgoProvider).fflags, b.gfortran))
+		}
+
+		// Add a single convenience action that does nothing to join the previous action,
+		// and better separate the cgo action dependencies of the build action from the
+		// build actions for its package dependencies.
+		return &Action{
+			Mode: "collect cgo",
+			Actor: ActorFunc(func(b *Builder, ctx context.Context, a *Action) error {
+				// Use the cgo run action's provider as our provider output,
+				// so it can be easily accessed by the build action.
+				a.Provider = a.Deps[0].Deps[0].Provider
+				return nil
+			}),
+			Deps:   collectDeps,
+			Objdir: objdir,
+		}
+	})
+
+	return cgoCollectAction
+}
+
 // VetAction returns the action for running go vet on package p.
 // It depends on the action for compiling p.
 // If the caller may be causing p to be installed, it is up to the caller