cmd/go/internal/work: pass *Action to toolchain methods

This shortens the args lists but also sets up better for
the content-based staleness changes.

While we're here, delete the now-unused Pkgpath method.

Change-Id: Ic60fa03efbc37a7c7fe9758a1cfa5dddef1a4151
Reviewed-on: https://go-review.googlesource.com/68335
Reviewed-by: David Crawshaw <crawshaw@golang.org>

diff --git a/src/cmd/go/internal/work/build.go b/src/cmd/go/internal/work/build.go
index 0a1783ed2fb0efe82948c650113ba5f0158049cc..2cc1682b150fbb90fc239f22bf715cacd06a02ad 100644 (file)
--- a/src/cmd/go/internal/work/build.go
+++ b/src/cmd/go/internal/work/build.go
@@ -1415,7 +1415,7 @@ func (b *Builder) build(a *Action) (err error) {
 
        // Compile Go.
        objpkg := objdir + "_pkg_.a"
-       ofile, out, err := BuildToolchain.gc(b, a.Package, objpkg, objdir, icfg.Bytes(), len(sfiles) > 0, gofiles)
+       ofile, out, err := BuildToolchain.gc(b, a, objpkg, icfg.Bytes(), len(sfiles) > 0, gofiles)
        if len(out) > 0 {
                b.showOutput(a.Package.Dir, a.Package.ImportPath, b.processOutput(out))
                if err != nil {
@@ -1458,7 +1458,7 @@ func (b *Builder) build(a *Action) (err error) {
 
        for _, file := range cfiles {
                out := file[:len(file)-len(".c")] + ".o"
-               if err := BuildToolchain.cc(b, a.Package, objdir, objdir+out, file); err != nil {
+               if err := BuildToolchain.cc(b, a, objdir+out, file); err != nil {
                        return err
                }
                objects = append(objects, out)
@@ -1466,7 +1466,7 @@ func (b *Builder) build(a *Action) (err error) {
 
        // Assemble .s files.
        if len(sfiles) > 0 {
-               ofiles, err := BuildToolchain.asm(b, a.Package, objdir, sfiles)
+               ofiles, err := BuildToolchain.asm(b, a, sfiles)
                if err != nil {
                        return err
                }
@@ -1490,7 +1490,7 @@ func (b *Builder) build(a *Action) (err error) {
        // If the Go compiler wrote an archive and the package is entirely
        // Go sources, there is no pack to execute at all.
        if len(objects) > 0 {
-               if err := BuildToolchain.pack(b, a.Package, objdir, objpkg, objects); err != nil {
+               if err := BuildToolchain.pack(b, a, objpkg, objects); err != nil {
                        return err
                }
        }
@@ -2137,19 +2137,17 @@ func mkAbs(dir, f string) string {
 type toolchain interface {
        // gc runs the compiler in a specific directory on a set of files
        // and returns the name of the generated output file.
-       gc(b *Builder, p *load.Package, archive, objdir string, importcfg []byte, asmhdr bool, gofiles []string) (ofile string, out []byte, err error)
+       gc(b *Builder, a *Action, archive string, importcfg []byte, asmhdr bool, gofiles []string) (ofile string, out []byte, err error)
        // cc runs the toolchain's C compiler in a directory on a C file
        // to produce an output file.
-       cc(b *Builder, p *load.Package, objdir, ofile, cfile string) error
+       cc(b *Builder, a *Action, ofile, cfile string) error
        // asm runs the assembler in a specific directory on specific files
        // and returns a list of named output files.
-       asm(b *Builder, p *load.Package, objdir string, sfiles []string) ([]string, error)
-       // pkgpath builds an appropriate path for a temporary package file.
-       Pkgpath(basedir string, p *load.Package) string
+       asm(b *Builder, a *Action, sfiles []string) ([]string, error)
        // pack runs the archive packer in a specific directory to create
        // an archive from a set of object files.
        // typically it is run in the object directory.
-       pack(b *Builder, p *load.Package, objdir, afile string, ofiles []string) error
+       pack(b *Builder, a *Action, afile string, ofiles []string) error
        // ld runs the linker to create an executable starting at mainpkg.
        ld(b *Builder, root *Action, out, importcfg string, allactions []*Action, mainpkg string, ofiles []string) error
        // ldShared runs the linker to create a shared library containing the pkgs built by toplevelactions
@@ -2176,20 +2174,15 @@ func (noToolchain) linker() string {
        return ""
 }
 
-func (noToolchain) gc(b *Builder, p *load.Package, archive, objdir string, importcfg []byte, asmhdr bool, gofiles []string) (ofile string, out []byte, err error) {
+func (noToolchain) gc(b *Builder, a *Action, archive string, importcfg []byte, asmhdr bool, gofiles []string) (ofile string, out []byte, err error) {
        return "", nil, noCompiler()
 }
 
-func (noToolchain) asm(b *Builder, p *load.Package, objdir string, sfiles []string) ([]string, error) {
+func (noToolchain) asm(b *Builder, a *Action, sfiles []string) ([]string, error) {
        return nil, noCompiler()
 }
 
-func (noToolchain) Pkgpath(basedir string, p *load.Package) string {
-       noCompiler()
-       return ""
-}
-
-func (noToolchain) pack(b *Builder, p *load.Package, objdir, afile string, ofiles []string) error {
+func (noToolchain) pack(b *Builder, a *Action, afile string, ofiles []string) error {
        return noCompiler()
 }
 
@@ -2201,7 +2194,7 @@ func (noToolchain) ldShared(b *Builder, toplevelactions []*Action, out, importcf
        return noCompiler()
 }
 
-func (noToolchain) cc(b *Builder, p *load.Package, objdir, ofile, cfile string) error {
+func (noToolchain) cc(b *Builder, a *Action, ofile, cfile string) error {
        return noCompiler()
 }
 
@@ -2216,7 +2209,9 @@ func (gcToolchain) linker() string {
        return base.Tool("link")
 }
 
-func (gcToolchain) gc(b *Builder, p *load.Package, archive, objdir string, importcfg []byte, asmhdr bool, gofiles []string) (ofile string, output []byte, err error) {
+func (gcToolchain) gc(b *Builder, a *Action, archive string, importcfg []byte, asmhdr bool, gofiles []string) (ofile string, output []byte, err error) {
+       p := a.Package
+       objdir := a.Objdir
        if archive != "" {
                ofile = archive
        } else {
@@ -2379,10 +2374,11 @@ CheckFlags:
        return c
 }
 
-func (gcToolchain) asm(b *Builder, p *load.Package, objdir string, sfiles []string) ([]string, error) {
+func (gcToolchain) asm(b *Builder, a *Action, sfiles []string) ([]string, error) {
+       p := a.Package
        // Add -I pkg/GOOS_GOARCH so #include "textflag.h" works in .s files.
        inc := filepath.Join(cfg.GOROOT, "pkg", "include")
-       args := []interface{}{cfg.BuildToolexec, base.Tool("asm"), "-trimpath", b.WorkDir, "-I", objdir, "-I", inc, "-D", "GOOS_" + cfg.Goos, "-D", "GOARCH_" + cfg.Goarch, buildAsmflags}
+       args := []interface{}{cfg.BuildToolexec, base.Tool("asm"), "-trimpath", b.WorkDir, "-I", a.Objdir, "-I", inc, "-D", "GOOS_" + cfg.Goos, "-D", "GOARCH_" + cfg.Goarch, buildAsmflags}
        if p.ImportPath == "runtime" && cfg.Goarch == "386" {
                for _, arg := range buildAsmflags {
                        if arg == "-dynlink" {
@@ -2392,7 +2388,7 @@ func (gcToolchain) asm(b *Builder, p *load.Package, objdir string, sfiles []stri
        }
        var ofiles []string
        for _, sfile := range sfiles {
-               ofile := objdir + sfile[:len(sfile)-len(".s")] + ".o"
+               ofile := a.Objdir + sfile[:len(sfile)-len(".s")] + ".o"
                ofiles = append(ofiles, ofile)
                a := append(args, "-o", ofile, mkAbs(p.Dir, sfile))
                if err := b.run(p.Dir, p.ImportPath, nil, a...); err != nil {
@@ -2428,17 +2424,12 @@ func toolVerify(b *Builder, p *load.Package, newTool string, ofile string, args
        return nil
 }
 
-func (gcToolchain) Pkgpath(basedir string, p *load.Package) string {
-       end := filepath.FromSlash(p.ImportPath + ".a")
-       return filepath.Join(basedir, end)
-}
-
-func (gcToolchain) pack(b *Builder, p *load.Package, objdir, afile string, ofiles []string) error {
+func (gcToolchain) pack(b *Builder, a *Action, afile string, ofiles []string) error {
        var absOfiles []string
        for _, f := range ofiles {
-               absOfiles = append(absOfiles, mkAbs(objdir, f))
+               absOfiles = append(absOfiles, mkAbs(a.Objdir, f))
        }
-       absAfile := mkAbs(objdir, afile)
+       absAfile := mkAbs(a.Objdir, afile)
 
        // The archive file should have been created by the compiler.
        // Since it used to not work that way, verify.
@@ -2448,6 +2439,7 @@ func (gcToolchain) pack(b *Builder, p *load.Package, objdir, afile string, ofile
                }
        }
 
+       p := a.Package
        if cfg.BuildN || cfg.BuildX {
                cmdline := str.StringList(base.Tool("pack"), "r", absAfile, absOfiles)
                b.Showcmd(p.Dir, "%s # internal", joinUnambiguously(cmdline))
@@ -2657,8 +2649,8 @@ func (gcToolchain) ldShared(b *Builder, toplevelactions []*Action, out, importcf
        return b.run(".", out, nil, cfg.BuildToolexec, base.Tool("link"), "-o", out, "-importcfg", importcfg, ldflags)
 }
 
-func (gcToolchain) cc(b *Builder, p *load.Package, objdir, ofile, cfile string) error {
-       return fmt.Errorf("%s: C source files not supported without cgo", mkAbs(p.Dir, cfile))
+func (gcToolchain) cc(b *Builder, a *Action, ofile, cfile string) error {
+       return fmt.Errorf("%s: C source files not supported without cgo", mkAbs(a.Package.Dir, cfile))
 }
 
 // The Gccgo toolchain.
@@ -2693,7 +2685,9 @@ func checkGccgoBin() {
        os.Exit(2)
 }
 
-func (tools gccgoToolchain) gc(b *Builder, p *load.Package, archive, objdir string, importcfg []byte, asmhdr bool, gofiles []string) (ofile string, output []byte, err error) {
+func (tools gccgoToolchain) gc(b *Builder, a *Action, archive string, importcfg []byte, asmhdr bool, gofiles []string) (ofile string, output []byte, err error) {
+       p := a.Package
+       objdir := a.Objdir
        out := "_go_.o"
        ofile = objdir + out
        gcargs := []string{"-g"}
@@ -2790,10 +2784,11 @@ func buildImportcfgSymlinks(b *Builder, root string, importcfg []byte) error {
        return nil
 }
 
-func (tools gccgoToolchain) asm(b *Builder, p *load.Package, objdir string, sfiles []string) ([]string, error) {
+func (tools gccgoToolchain) asm(b *Builder, a *Action, sfiles []string) ([]string, error) {
+       p := a.Package
        var ofiles []string
        for _, sfile := range sfiles {
-               ofile := objdir + sfile[:len(sfile)-len(".s")] + ".o"
+               ofile := a.Objdir + sfile[:len(sfile)-len(".s")] + ".o"
                ofiles = append(ofiles, ofile)
                sfile = mkAbs(p.Dir, sfile)
                defs := []string{"-D", "GOOS_" + cfg.Goos, "-D", "GOARCH_" + cfg.Goarch}
@@ -2802,7 +2797,7 @@ func (tools gccgoToolchain) asm(b *Builder, p *load.Package, objdir string, sfil
                }
                defs = tools.maybePIC(defs)
                defs = append(defs, b.gccArchArgs()...)
-               err := b.run(p.Dir, p.ImportPath, nil, tools.compiler(), "-xassembler-with-cpp", "-I", objdir, "-c", "-o", ofile, defs, sfile)
+               err := b.run(p.Dir, p.ImportPath, nil, tools.compiler(), "-xassembler-with-cpp", "-I", a.Objdir, "-c", "-o", ofile, defs, sfile)
                if err != nil {
                        return nil, err
                }
@@ -2810,10 +2805,6 @@ func (tools gccgoToolchain) asm(b *Builder, p *load.Package, objdir string, sfil
        return ofiles, nil
 }
 
-func (gccgoToolchain) Pkgpath(basedir string, p *load.Package) string {
-       return gccgoArchive(basedir, p.ImportPath)
-}
-
 func gccgoArchive(basedir, imp string) string {
        end := filepath.FromSlash(imp + ".a")
        afile := filepath.Join(basedir, end)
@@ -2821,7 +2812,9 @@ func gccgoArchive(basedir, imp string) string {
        return filepath.Join(filepath.Dir(afile), "lib"+filepath.Base(afile))
 }
 
-func (gccgoToolchain) pack(b *Builder, p *load.Package, objdir, afile string, ofiles []string) error {
+func (gccgoToolchain) pack(b *Builder, a *Action, afile string, ofiles []string) error {
+       p := a.Package
+       objdir := a.Objdir
        var absOfiles []string
        for _, f := range ofiles {
                absOfiles = append(absOfiles, mkAbs(objdir, f))
@@ -3105,7 +3098,8 @@ func (tools gccgoToolchain) ldShared(b *Builder, toplevelactions []*Action, out,
        return tools.link(b, fakeRoot, out, importcfg, allactions, "", nil, "shared", out)
 }
 
-func (tools gccgoToolchain) cc(b *Builder, p *load.Package, objdir, ofile, cfile string) error {
+func (tools gccgoToolchain) cc(b *Builder, a *Action, ofile, cfile string) error {
+       p := a.Package
        inc := filepath.Join(cfg.GOROOT, "pkg", "include")
        cfile = mkAbs(p.Dir, cfile)
        defs := []string{"-D", "GOOS_" + cfg.Goos, "-D", "GOARCH_" + cfg.Goarch}
@@ -3119,7 +3113,7 @@ func (tools gccgoToolchain) cc(b *Builder, p *load.Package, objdir, ofile, cfile
        }
        defs = tools.maybePIC(defs)
        return b.run(p.Dir, p.ImportPath, nil, envList("CC", cfg.DefaultCC), "-Wall", "-g",
-               "-I", objdir, "-I", inc, "-o", ofile, defs, "-c", cfile)
+               "-I", a.Objdir, "-I", inc, "-o", ofile, defs, "-c", cfile)
 }
 
 // maybePIC adds -fPIC to the list of arguments if needed.
@@ -3557,7 +3551,7 @@ func (b *Builder) cgo(a *Action, cgoExe, objdir string, pcCFLAGS, pcLDFLAGS, cgo
        case "gccgo":
                defunC := objdir + "_cgo_defun.c"
                defunObj := objdir + "_cgo_defun.o"
-               if err := BuildToolchain.cc(b, p, objdir, defunObj, defunC); err != nil {
+               if err := BuildToolchain.cc(b, a, defunObj, defunC); err != nil {
                        return nil, nil, err
                }
                outObj = append(outObj, defunObj)
@@ -3732,7 +3726,7 @@ func (b *Builder) swigDoIntSize(objdir string) (intsize string, err error) {
 
        p := load.GoFilesPackage(srcs)
 
-       if _, _, e := BuildToolchain.gc(b, p, "", objdir, nil, false, srcs); e != nil {
+       if _, _, e := BuildToolchain.gc(b, &Action{Package: p, Objdir: objdir}, "", nil, false, srcs); e != nil {
                return "32", nil
        }
        return "64", nil