code review 5708054: cmd/go: fixes

src/cmd/go/build.go

 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package main
 
 import (
         "bytes"
         "container/heap"
         "errors"
         "fmt"
         "go/build"
         "io"
         "io/ioutil"
         "os"
         "os/exec"
         "path"
         "path/filepath"
         "regexp"
         "runtime"
         "strings"
         "sync"
 )
 
 var cmdBuild = &Command{
-        UsageLine: "build [-a] [-n] [-o output] [-p n] [-v] [-x] [-work] [importpath... | gofiles...]",
+        UsageLine: "build [-o output] [build flags] [packages]",
         Short:     "compile packages and dependencies",
         Long: `
 Build compiles the packages named by the import paths,
 along with their dependencies, but it does not install the results.
 
 If the arguments are a list of .go files, build treats them as a list
 of source files specifying a single package.
 
 When the command line specifies a single main package,
-build writes the resulting executable to output (default a.out).
+build writes the resulting executable to output.
 Otherwise build compiles the packages but discards the results,
 serving only as a check that the packages can be built.
 
-The -a flag forces rebuilding of packages that are already up-to-date.
-The -n flag prints the commands but does not run them.
-The -v flag prints the names of packages as they are compiled.
-The -x flag prints the commands.
+The -o flag specifies the output file name.  If not specified, the
+name is packagename.a (for a non-main package) or the base
+name of the first source file (for a main package).
 
-The -o flag specifies the output file name.
-It is an error to use -o when the command line specifies multiple packages.
+The build flags are shared by the build, install, run, and test commands:
 
-The -p flag specifies the number of builds that can be run in parallel.
-The default is the number of CPUs available.
+        -a
+                force rebuilding of packages that are already up-to-date.
+        -n
+                print the commands but does not run them.
+        -p n
+                the number of builds that can be run in parallel.
+                The default is the number of CPUs available.
+        -v
+                print the names of packages as they are compiled.
+        -work
+                print the name of the temporary work directory and
+                do not delete it when exiting.
+        -x
+                print the commands.
 
-The -work flag causes build to print the name of the temporary work
-directory and not delete it when exiting.
+        -gccgoflags 'arg list'
+                arguments to pass on each gccgo compiler/linker invocation
+        -gcflags 'arg list'
+                arguments to pass on each 5g, 6g, or 8g compiler invocation
+        -ldflags 'flag list'
+                arguments to pass on each 5l, 6l, or 8l linker invocation
+        -tags 'tag list'
+                a list of build tags to consider satisfied during the build.
+                See the documentation for the go/build package for
+                more information about build tags.
 
-For more about import paths, see 'go help importpath'.
+For more about specifying packages, see 'go help packages'.
 
 See also: go install, go get, go clean.
         `,
 }
 
 func init() {
         // break init cycle
         cmdBuild.Run = runBuild
         cmdInstall.Run = runInstall
 
         addBuildFlags(cmdBuild)
         addBuildFlags(cmdInstall)
 }
 
 // Flags set by multiple commands.
 var buildA bool               // -a flag
 var buildN bool               // -n flag
 var buildP = runtime.NumCPU() // -p flag
 var buildV bool               // -v flag
 var buildX bool               // -x flag
 var buildO = cmdBuild.Flag.String("o", "", "output file")
-var buildWork bool // -work flag
+var buildWork bool           // -work flag
+var buildGcflags []string    // -gcflags flag
+var buildLdflags []string    // -ldflags flag
+var buildGccgoflags []string // -gccgoflags flag
 
-var buildContext = build.DefaultContext
+var buildContext = build.Default
 
 // addBuildFlags adds the flags common to the build and install commands.
 func addBuildFlags(cmd *Command) {
         cmd.Flag.BoolVar(&buildA, "a", false, "")
         cmd.Flag.BoolVar(&buildN, "n", false, "")
         cmd.Flag.IntVar(&buildP, "p", buildP, "")
         cmd.Flag.BoolVar(&buildV, "v", false, "")
         cmd.Flag.BoolVar(&buildX, "x", false, "")
         cmd.Flag.BoolVar(&buildWork, "work", false, "")
-
-        // TODO(rsc): This -t flag is used by buildscript.sh but
-        // not documented.  Should be documented but the
-        // usage lines are getting too long.  Probably need to say
-        // that these flags are applicable to every command and
-        // document them in one help message instead of on every
-        // command's help message.
-        cmd.Flag.Var((*stringsFlag)(&buildContext.BuildTags), "t", "")
+        cmd.Flag.Var((*stringsFlag)(&buildGcflags), "gcflags", "")
+        cmd.Flag.Var((*stringsFlag)(&buildLdflags), "ldflags", "")
+        cmd.Flag.Var((*stringsFlag)(&buildGccgoflags), "gccgoflags", "")
+        cmd.Flag.Var((*stringsFlag)(&buildContext.BuildTags), "tags", "")
 }
 
 type stringsFlag []string
 
 func (v *stringsFlag) Set(s string) error {
-        *v = append(*v, s)
+        *v = strings.Fields(s)
         return nil
 }
 
 func (v *stringsFlag) String() string {
         return "<stringsFlag>"
 }
 
 func runBuild(cmd *Command, args []string) {
         var b builder
         b.init()
 
-        var pkgs []*Package
-        if len(args) > 0 && strings.HasSuffix(args[0], ".go") {
-                pkg := goFilesPackage(args, "")
-                pkgs = append(pkgs, pkg)
-        } else {
-                pkgs = packagesForBuild(args)
-        }
+        pkgs := packagesForBuild(args)
 
         if len(pkgs) == 1 && pkgs[0].Name == "main" && *buildO == "" {
                 _, *buildO = path.Split(pkgs[0].ImportPath)
-                if b.goos == "windows" {
+                if goos == "windows" {
                         *buildO += ".exe"
                 }
         }
 
         if *buildO != "" {
                 if len(pkgs) > 1 {
                         fatalf("go build: cannot use -o with multiple packages")
                 }
                 p := pkgs[0]
                 p.target = "" // must build - not up to date
                 a := b.action(modeInstall, modeBuild, p)
                 a.target = *buildO
                 b.do(a)
                 return
         }
 
         a := &action{}
         for _, p := range packages(args) {
                 a.deps = append(a.deps, b.action(modeBuild, modeBuild, p))
         }
         b.do(a)
 }
 
 var cmdInstall = &Command{
-        UsageLine: "install [-a] [-n] [-p n] [-v] [-x] [-work] [importpath...]",
+        UsageLine: "install [build flags] [packages]",
         Short:     "compile and install packages and dependencies",
         Long: `
 Install compiles and installs the packages named by the import paths,
 along with their dependencies.
 
-The -a flag forces reinstallation of packages that are already up-to-date.
-The -n flag prints the commands but does not run them.
-The -v flag prints the names of packages as they are compiled.
-The -x flag prints the commands.
-
-The -p flag specifies the number of builds that can be run in parallel.
-The default is the number of CPUs available.
-
-The -work flag causes build to print the name of the temporary work
-directory and not delete it when exiting.
-
-For more about import paths, see 'go help importpath'.
+For more about the build flags, see 'go help build'.
+For more about specifying packages, see 'go help packages'.
 
 See also: go build, go get, go clean.
         `,
 }
 
 func runInstall(cmd *Command, args []string) {
         pkgs := packagesForBuild(args)
 
+        for _, p := range pkgs {
+                if p.Target == "" && (!p.Standard || p.ImportPath != "unsafe") {
+                        errorf("go install: no install location for %s", p.ImportPath)
+                }
+        }
+        exitIfErrors()
+
         var b builder
         b.init()
         a := &action{}
         for _, p := range pkgs {
                 a.deps = append(a.deps, b.action(modeInstall, modeInstall, p))
         }
         b.do(a)
 }
 
+// Global build parameters (used during package load)
+var (
+        goarch    string
+        goos      string
+        archChar  string
+        exeSuffix string
+)
+
+func init() {
+        goarch = buildContext.GOARCH
+        goos = buildContext.GOOS
+        if goos == "windows" {
+                exeSuffix = ".exe"
+        }
+        var err error
+        archChar, err = build.ArchChar(goarch)
+        if err != nil {
+                fatalf("%s", err)
+        }
+}
+
 // A builder holds global state about a build.
-// It does not hold per-package state, because eventually we will
-// build packages in parallel, and the builder will be shared.
+// It does not hold per-package state, because we
+// build packages in parallel, and the builder is shared.
 type builder struct {
         work        string               // the temporary work directory (ends in filepath.Separator)
-        arch        string               // e.g., "6"
-        goarch      string               // the $GOARCH
-        goos        string               // the $GOOS
-        exe         string               // the executable suffix - "" or ".exe"
-        gcflags     []string             // additional flags for Go compiler
         actionCache map[cacheKey]*action // a cache of already-constructed actions
         mkdirCache  map[string]bool      // a cache of created directories
         print       func(args ...interface{}) (int, error)
 
         output    sync.Mutex
         scriptDir string // current directory in printed script
 
         exec      sync.Mutex
         readySema chan bool
         ready     actionQueue
@@ skipping 33 matching lines @@
 // buildMode specifies the build mode:
 // are we just building things or also installing the results?
 type buildMode int
 
 const (
         modeBuild buildMode = iota
         modeInstall
 )
 
 var (
-        gobin  = build.Path[0].BinDir()
-        goroot = build.Path[0].Path
+        goroot       = filepath.Clean(runtime.GOROOT())
+        gobin        = defaultGobin()
+        gorootSrcPkg = filepath.Join(goroot, "src/pkg")
+        gorootPkg    = filepath.Join(goroot, "pkg")
+        gorootSrc    = filepath.Join(goroot, "src")
 )
 
+func defaultGobin() string {
+        if s := os.Getenv("GOBIN"); s != "" {
+                return s
+        }
+        return filepath.Join(goroot, "bin")
+}
+
 func (b *builder) init() {
         var err error
         b.print = fmt.Print
         b.actionCache = make(map[cacheKey]*action)
         b.mkdirCache = make(map[string]bool)
-        b.goarch = buildContext.GOARCH
-        b.goos = buildContext.GOOS
-        if b.goos == "windows" {
-                b.exe = ".exe"
-        }
-        b.gcflags = strings.Fields(os.Getenv("GCFLAGS"))
-
-        b.arch, err = build.ArchChar(b.goarch)
-        if err != nil {
-                fatalf("%s", err)
-        }
 
         if buildN {
                 b.work = "$WORK"
         } else {
                 b.work, err = ioutil.TempDir("", "go-build")
                 if err != nil {
                         fatalf("%s", err)
                 }
                 if buildX || buildWork {
                         fmt.Printf("WORK=%s\n", b.work)
                 }
                 if !buildWork {
                         atexit(func() { os.RemoveAll(b.work) })
                 }
         }
 }
 
 // goFilesPackage creates a package for building a collection of Go files
-// (typically named on the command line).  If target is given, the package
-// target is target.  Otherwise, the target is named p.a for
+// (typically named on the command line).  The target is named p.a for
 // package p or named after the first Go file for package main.
-func goFilesPackage(gofiles []string, target string) *Package {
+func goFilesPackage(gofiles []string) *Package {
         // TODO: Remove this restriction.
         for _, f := range gofiles {
-                if !strings.HasSuffix(f, ".go") || strings.Contains(f, "/") || strings.Contains(f, string(filepath.Separator)) {
-                        fatalf("named files must be in current directory and .go files")
+                if !strings.HasSuffix(f, ".go") {
+                        fatalf("named files must be .go files")
                 }
         }
 
-        // Synthesize fake "directory" that only shows those two files,
+        var stk importStack
+        ctxt := buildContext
+        ctxt.UseAllFiles = true
+
+        // Synthesize fake "directory" that only shows the named files,
         // to make it look like this is a standard package or
-        // command directory.
-        var dir []os.FileInfo
+        // command directory.  So that local imports resolve
+        // consistently, the files must all be in the same directory.
+        var dirent []os.FileInfo
+        var dir string
         for _, file := range gofiles {
                 fi, err := os.Stat(file)
                 if err != nil {
                         fatalf("%s", err)
                 }
                 if fi.IsDir() {
                         fatalf("%s is a directory, should be a Go file", file)
                 }
-                dir = append(dir, fi)
+                dir1, _ := filepath.Split(file)
+                if dir == "" {
+                        dir = dir1
+                } else if dir != dir1 {
+                        fatalf("named files must all be in one directory; have %s and %s", dir, dir1)
+                }
+                dirent = append(dirent, fi)
         }
-        ctxt := buildContext
-        ctxt.ReadDir = func(string) ([]os.FileInfo, error) { return dir, nil }
-        pwd, _ := os.Getwd()
-        var stk importStack
-        pkg := scanPackage(&ctxt, &build.Tree{Path: "."}, "<command line>", "<command line>", pwd+"/.", &stk, true)
-        if pkg.Error != nil {
-                fatalf("%s", pkg.Error)
+        ctxt.ReadDir = func(string) ([]os.FileInfo, error) { return dirent, nil }
+
+        if !filepath.IsAbs(dir) {
+                dir = filepath.Join(cwd, dir)
         }
-        printed := map[error]bool{}
-        for _, err := range pkg.DepsErrors {
-                // Since these are errors in dependencies,
-                // the same error might show up multiple times,
-                // once in each package that depends on it.
-                // Only print each once.
-                if !printed[err] {
-                        printed[err] = true
-                        errorf("%s", err)
+
+        bp, err := ctxt.ImportDir(dir, 0)
+        pkg := new(Package)
+        pkg.load(&stk, bp, err)
+
+        pkg.ImportPath = "command-line arguments"
+        if *buildO == "" {
+                if pkg.Name == "main" {
+                        _, elem := filepath.Split(gofiles[0])
+                        *buildO = elem[:len(elem)-len(".go")]
+                } else {
+                        *buildO = pkg.Name + ".a"
                 }
         }
-        if target != "" {
-                pkg.target = target
-        } else if pkg.Name == "main" {
-                pkg.target = gofiles[0][:len(gofiles[0])-len(".go")]
-        } else {
-                pkg.target = pkg.Name + ".a"
-        }
-        pkg.ImportPath = "_/" + pkg.target
-        exitIfErrors()
+        pkg.target = ""
+        pkg.Target = ""
+        pkg.Stale = true
+
+        computeStale([]*Package{pkg})
         return pkg
 }
 
 // action returns the action for applying the given operation (mode) to the package.
 // depMode is the action to use when building dependencies.
 func (b *builder) action(mode buildMode, depMode buildMode, p *Package) *action {
         key := cacheKey{mode, p}
         a := b.actionCache[key]
         if a != nil {
                 return a
         }
 
-        a = &action{p: p, pkgdir: p.t.PkgDir()}
+        a = &action{p: p, pkgdir: p.build.PkgRoot}
         if p.pkgdir != "" { // overrides p.t
                 a.pkgdir = p.pkgdir
         }
 
         b.actionCache[key] = a
 
         for _, p1 := range p.imports {
                 a.deps = append(a.deps, b.action(depMode, depMode, p1))
         }
 
         // If we are not doing a cross-build, then record the binary we'll
         // generate for cgo as a dependency of the build of any package
         // using cgo, to make sure we do not overwrite the binary while
         // a package is using it.  If this is a cross-build, then the cgo we
         // are writing is not the cgo we need to use.
-        if b.goos == runtime.GOOS && b.goarch == runtime.GOARCH {
+        if goos == runtime.GOOS && goarch == runtime.GOARCH {
                 if len(p.CgoFiles) > 0 || p.Standard && p.ImportPath == "runtime/cgo" {
                         var stk importStack
                         p1 := loadPackage("cmd/cgo", &stk)
                         if p1.Error != nil {
                                 fatalf("load cmd/cgo: %v", p1.Error)
                         }
                         a.cgo = b.action(depMode, depMode, p1)
                         a.deps = append(a.deps, a.cgo)
                 }
         }
 
         if p.Standard {
                 switch p.ImportPath {
                 case "builtin", "unsafe":
                         // Fake packages - nothing to build.
                         return a
                 }
                 // gccgo standard library is "fake" too.
                 if _, ok := buildToolchain.(gccgoToolchain); ok {
                         // the target name is needed for cgo.
                         a.target = p.target
                         return a
                 }
         }
 
-        if !p.Stale && !buildA && p.target != "" {
+        if !p.Stale && p.target != "" {
                 // p.Stale==false implies that p.target is up-to-date.
                 // Record target name for use by actions depending on this one.
                 a.target = p.target
                 return a
         }
 
-        a.objdir = filepath.Join(b.work, filepath.FromSlash(a.p.ImportPath+"/_obj")) + string(filepath.Separator)
-        a.objpkg = buildToolchain.pkgpath(b.work, a.p)
+        prefix := "obj"
+        if p.target == "" && p.Dir == p.ImportPath {
+                // Imported via local path.  No permanent target.
+                mode = modeBuild
+                prefix = "local"
+        }
+        a.objdir = filepath.Join(b.work, prefix, a.p.ImportPath, "_obj") + string(filepath.Separator)
+        a.objpkg = buildToolchain.pkgpath(b.work+"/"+prefix, a.p, false)
         a.link = p.Name == "main"
 
         switch mode {
         case modeInstall:
                 a.f = (*builder).install
                 a.deps = []*action{b.action(modeBuild, depMode, p)}
                 a.target = a.p.target
         case modeBuild:
                 a.f = (*builder).build
                 a.target = a.objpkg
                 if a.link {
                         // An executable file.
                         // (This is the name of a temporary file.)
-                        a.target = a.objdir + "a.out" + b.exe
+                        a.target = a.objdir + "a.out" + exeSuffix
                 }
         }
 
         return a
 }
 
 // actionList returns the list of actions in the dag rooted at root
 // as visited in a depth-first post-order traversal.
 func actionList(root *action) []*action {
         seen := map[*action]bool{}
@@ skipping 129 matching lines @@
                 return err
         }
 
         var gofiles, cfiles, sfiles, objects, cgoObjects []string
         gofiles = append(gofiles, a.p.GoFiles...)
         cfiles = append(cfiles, a.p.CFiles...)
         sfiles = append(sfiles, a.p.SFiles...)
 
         // Run cgo.
         if len(a.p.CgoFiles) > 0 {
-                // In a package using cgo, cgo compiles the C and assembly files with gcc.  
+                // In a package using cgo, cgo compiles the 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.
                 var gccfiles []string
                 if a.p.Standard && a.p.ImportPath == "runtime/cgo" {
                         filter := func(files, nongcc, gcc []string) ([]string, []string) {
                                 for _, f := range files {
                                         if strings.HasPrefix(f, "gcc_") {
                                                 gcc = append(gcc, f)
                                         } else {
@@ skipping 18 matching lines @@
                 if err != nil {
                         return err
                 }
                 cgoObjects = append(cgoObjects, outObj...)
                 gofiles = append(gofiles, outGo...)
         }
 
         // Prepare Go import path list.
         inc := b.includeArgs("-I", a.deps)
 
+        // In what directory shall we run the Go compiler?
+        // We only pass absolute paths, so most of the time it doesn't matter.
+        // Default to the root directory.
+        // However, if the package contains local imports (./ or ../)
+        // then we need to run the compiler in a directory in the parallel
+        // tree of local package objects, so that those imports resolve to the
+        // compiled package objects.
+        gcdir := filepath.Clean("/")
+        for _, imp := range a.p.Imports {
+                if build.IsLocalImport(imp) {
+                        dir := a.p.Dir
+                        if filepath.Separator == '\\' {
+                                // Avoid use of : on Windows.
+                                dir = strings.Replace(dir, ":", "_", -1)
+                        }
+                        gcdir = filepath.Join(b.work, "local", dir)
+                        if err := b.mkdir(gcdir); err != nil {
+                                return err
+                        }
+                        break
+                }
+        }
+
         // Compile Go.
         if len(gofiles) > 0 {
-                if out, err := buildToolchain.gc(b, a.p, obj, inc, gofiles); err != nil {
+                if out, err := buildToolchain.gc(b, a.p, obj, gcdir, inc, gofiles); err != nil {
                         return err
                 } else {
                         objects = append(objects, out)
                 }
         }
 
         // Copy .h files named for goos or goarch or goos_goarch
         // to names using GOOS and GOARCH.
         // For example, defs_linux_amd64.h becomes defs_GOOS_GOARCH.h.
-        _goos_goarch := "_" + b.goos + "_" + b.goarch + ".h"
-        _goos := "_" + b.goos + ".h"
-        _goarch := "_" + b.goarch + ".h"
+        _goos_goarch := "_" + goos + "_" + goarch + ".h"
+        _goos := "_" + goos + ".h"
+        _goarch := "_" + goarch + ".h"
         for _, file := range a.p.HFiles {
                 switch {
                 case strings.HasSuffix(file, _goos_goarch):
                         targ := file[:len(file)-len(_goos_goarch)] + "_GOOS_GOARCH.h"
-                        if err := b.copyFile(obj+targ, filepath.Join(a.p.Dir, file), 0666); err != nil {
+                        if err := b.copyFile(a, obj+targ, filepath.Join(a.p.Dir, file), 0666); err != nil {
                                 return err
                         }
                 case strings.HasSuffix(file, _goarch):
                         targ := file[:len(file)-len(_goarch)] + "_GOARCH.h"
-                        if err := b.copyFile(obj+targ, filepath.Join(a.p.Dir, file), 0666); err != nil {
+                        if err := b.copyFile(a, obj+targ, filepath.Join(a.p.Dir, file), 0666); err != nil {
                                 return err
                         }
                 case strings.HasSuffix(file, _goos):
                         targ := file[:len(file)-len(_goos)] + "_GOOS.h"
-                        if err := b.copyFile(obj+targ, filepath.Join(a.p.Dir, file), 0666); err != nil {
+                        if err := b.copyFile(a, obj+targ, filepath.Join(a.p.Dir, file), 0666); err != nil {
                                 return err
                         }
                 }
         }
 
         for _, file := range cfiles {
-                out := file[:len(file)-len(".c")] + "." + b.arch
+                out := file[:len(file)-len(".c")] + "." + archChar
                 if err := buildToolchain.cc(b, a.p, obj, obj+out, file); err != nil {
                         return err
                 }
                 objects = append(objects, out)
         }
 
         // Assemble .s files.
         for _, file := range sfiles {
-                out := file[:len(file)-len(".s")] + "." + b.arch
+                out := file[:len(file)-len(".s")] + "." + archChar
                 if err := buildToolchain.asm(b, a.p, obj, obj+out, file); err != nil {
                         return err
                 }
                 objects = append(objects, out)
         }
 
         // NOTE(rsc): On Windows, it is critically important that the
         // gcc-compiled objects (cgoObjects) be listed after the ordinary
         // objects in the archive.  I do not know why this is.
         // http://golang.org/issue/2601
@@ skipping 36 matching lines @@
 
         // remove object dir to keep the amount of
         // garbage down in a large build.  On an operating system
         // with aggressive buffering, cleaning incrementally like
         // this keeps the intermediate objects from hitting the disk.
         if !buildWork {
                 defer os.RemoveAll(a1.objdir)
                 defer os.Remove(a1.target)
         }
 
-        return b.copyFile(a.target, a1.target, perm)
+        return b.copyFile(a, a.target, a1.target, perm)
 }
 
 // includeArgs returns the -I or -L directory list for access
 // to the results of the list of actions.
 func (b *builder) includeArgs(flag string, all []*action) []string {
         inc := []string{}
         incMap := map[string]bool{
-                b.work:                 true, // handled later
-                build.Path[0].PkgDir(): true, // goroot
-                "":                     true, // ignore empty strings
+                b.work + "/obj": true, // handled later
+                gorootPkg:       true,
+                "":              true, // ignore empty strings
         }
 
         // Look in the temporary space for results of test-specific actions.
         // This is the $WORK/my/package/_test directory for the
         // package being built, so there are few of these.
         for _, a1 := range all {
-                if dir := a1.pkgdir; dir != a1.p.t.PkgDir() && !incMap[dir] {
+                if dir := a1.pkgdir; dir != a1.p.build.PkgRoot && !incMap[dir] {
                         incMap[dir] = true
                         inc = append(inc, flag, dir)
                 }
         }
 
         // Also look in $WORK for any non-test packages that have
         // been built but not installed.
-        inc = append(inc, flag, b.work)
+        inc = append(inc, flag, b.work+"/obj")
 
         // Finally, look in the installed package directories for each action.
         for _, a1 := range all {
-                if dir := a1.pkgdir; dir == a1.p.t.PkgDir() && !incMap[dir] {
+                if dir := a1.pkgdir; dir == a1.p.build.PkgRoot && !incMap[dir] {
                         if _, ok := buildToolchain.(gccgoToolchain); ok {
                                 dir = filepath.Join(filepath.Dir(dir), "gccgo", filepath.Base(dir))
                         }
                         incMap[dir] = true
                         inc = append(inc, flag, dir)
                 }
         }
 
         return inc
 }
 
 // copyFile is like 'cp src dst'.
-func (b *builder) copyFile(dst, src string, perm os.FileMode) error {
+func (b *builder) copyFile(a *action, dst, src string, perm os.FileMode) error {
         if buildN || buildX {
                 b.showcmd("", "cp %s %s", src, dst)
                 if buildN {
                         return nil
                 }
         }
 
         sf, err := os.Open(src)
         if err != nil {
                 return err
@@ skipping 125 matching lines @@
 //      $ go build
 //      # fmt
 //      /usr/gopher/go/src/pkg/fmt/print.go:1090: undefined: asdf
 //      $
 //
 // showOutput also replaces references to the work directory with $WORK.
 //
 func (b *builder) showOutput(dir, desc, out string) {
         prefix := "# " + desc
         suffix := "\n" + out
-        pwd, _ := os.Getwd()
-        if reldir, err := filepath.Rel(pwd, dir); err == nil && len(reldir) < len(dir) {
+        if reldir := shortPath(dir); reldir != dir {
                 suffix = strings.Replace(suffix, " "+dir, " "+reldir, -1)
                 suffix = strings.Replace(suffix, "\n"+dir, "\n"+reldir, -1)
         }
         suffix = strings.Replace(suffix, " "+b.work, " $WORK", -1)
 
         b.output.Lock()
         defer b.output.Unlock()
         b.print(prefix, suffix)
 }
 
+// shortPath returns an absolute or relative name for path, whatever is shorter.
+func shortPath(path string) string {
+        if rel, err := filepath.Rel(cwd, path); err == nil && len(rel) < len(path) {
+                return rel
+        }
+        return path
+}
+
 // relPaths returns a copy of paths with absolute paths
 // made relative to the current directory if they would be shorter.
 func relPaths(paths []string) []string {
         var out []string
         pwd, _ := os.Getwd()
         for _, p := range paths {
                 rel, err := filepath.Rel(pwd, p)
                 if err == nil && len(rel) < len(p) {
                         p = rel
                 }
                 out = append(out, p)
         }
         return out
 }
 
 // errPrintedOutput is a special error indicating that a command failed
 // but that it generated output as well, and that output has already
 // been printed, so there's no point showing 'exit status 1' or whatever
 // the wait status was.  The main executor, builder.do, knows not to
 // print this error.
 var errPrintedOutput = errors.New("already printed output - no need to show error")
 
 // run runs the command given by cmdline in the directory dir.
 // If the commnd fails, run prints information about the failure
 // and returns a non-nil error.
-func (b *builder) run(dir string, desc string, cmdargs ...interface{}) error {
+func (b *builder) run(dir, shortenDir string, desc string, cmdargs ...interface{}) error {
         out, err := b.runOut(dir, desc, cmdargs...)
         if len(out) > 0 {
                 if out[len(out)-1] != '\n' {
                         out = append(out, '\n')
                 }
                 if desc == "" {
                         desc = b.fmtcmd(dir, "%s", strings.Join(stringList(cmdargs...), " "))
                 }
-                b.showOutput(dir, desc, string(out))
+                b.showOutput(shortenDir, desc, string(out))
                 if err != nil {
                         err = errPrintedOutput
                 }
         }
         return err
 }
 
 // runOut runs the command given by cmdline in the directory dir.
 // It returns the command output and any errors that occurred.
 func (b *builder) runOut(dir string, desc string, cmdargs ...interface{}) ([]byte, error) {
@@ skipping 50 matching lines @@
         // instead of creating an actual work directory that won't be used.
         // Leave paths beginning with $WORK alone too.
         if filepath.IsAbs(f) || strings.HasPrefix(f, "$WORK") {
                 return f
         }
         return filepath.Join(dir, f)
 }
 
 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 *Package, obj string, importArgs []string, gofiles []string) (ofile string, err error)
+        // and returns the name of the generated output file.
+        // The compiler runs in the directory dir.
+        gc(b *builder, p *Package, obj, dir string, importArgs []string, gofiles []string) (ofile string, 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 *Package, objdir, ofile, cfile string) error
         // asm runs the assembler in a specific directory on a specific file
-        // to generate the named output file. 
+        // to generate the named output file.
         asm(b *builder, p *Package, obj, ofile, sfile string) error
         // pkgpath creates the appropriate destination path for a package file.
-        pkgpath(basedir string, p *Package) string
+        pkgpath(basedir string, p *Package, install bool) string
         // 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 *Package, objDir, afile string, ofiles []string) error
         // ld runs the linker to create a package starting at mainpkg.
         ld(b *builder, p *Package, out string, allactions []*action, mainpkg string, ofiles []string) error
+
+        compiler() string
+        linker() string
 }
 
 type goToolchain struct{}
 type gccgoToolchain struct{}
 
 var buildToolchain toolchain
 
 func init() {
+        // TODO(rsc): Decide how to trigger gccgo.  Issue 3157.
         if os.Getenv("GC") == "gccgo" {
                 buildToolchain = gccgoToolchain{}
         } else {
                 buildToolchain = goToolchain{}
         }
 }
 
 // The Go toolchain.
 
-func (goToolchain) gc(b *builder, p *Package, obj string, importArgs []string, gofiles []string) (ofile string, err error) {
-        out := "_go_." + b.arch
+func (goToolchain) compiler() string {
+        return tool(archChar + "g")
+}
+
+func (goToolchain) linker() string {
+        return tool(archChar + "l")
+}
+
+func (goToolchain) gc(b *builder, p *Package, obj, dir string, importArgs []string, gofiles []string) (ofile string, err error) {
+        out := "_go_." + archChar
         ofile = obj + out
         gcargs := []string{"-p", p.ImportPath}
         if p.Standard && p.ImportPath == "runtime" {
                 // runtime compiles with a special 6g flag to emit
                 // additional reflect type data.
                 gcargs = append(gcargs, "-+")
         }
 
-        args := stringList(tool(b.arch+"g"), "-o", ofile, b.gcflags, gcargs, importArgs)
+        args := stringList(tool(archChar+"g"), "-o", ofile, buildGcflags, gcargs, importArgs)
         for _, f := range gofiles {
                 args = append(args, mkAbs(p.Dir, f))
         }
-        return ofile, b.run(p.Dir, p.ImportPath, args)
+        return ofile, b.run(dir, p.Dir, p.ImportPath, args)
 }
 
 func (goToolchain) asm(b *builder, p *Package, obj, ofile, sfile string) error {
         sfile = mkAbs(p.Dir, sfile)
-        return b.run(p.Dir, p.ImportPath, tool(b.arch+"a"), "-I", obj, "-o", ofile, "-DGOOS_"+b.goos, "-DGOARCH_"+b.goarch, sfile)
+        return b.run(p.Dir, p.Dir, p.ImportPath, tool(archChar+"a"), "-I", obj, "-o", ofile, "-DGOOS_"+goos, "-DGOARCH_"+goarch, sfile)
 }
 
-func (goToolchain) pkgpath(basedir string, p *Package) string {
-        return filepath.Join(basedir, filepath.FromSlash(p.ImportPath+".a"))
+func (goToolchain) pkgpath(basedir string, p *Package, install bool) string {
+        end := filepath.FromSlash(p.ImportPath + ".a")
+        if install {
+                return filepath.Join(basedir, buildContext.GOOS+"_"+buildContext.GOARCH, end)
+        }
+        return filepath.Join(basedir, end)
 }
 
 func (goToolchain) pack(b *builder, p *Package, objDir, afile string, ofiles []string) error {
         var absOfiles []string
         for _, f := range ofiles {
                 absOfiles = append(absOfiles, mkAbs(objDir, f))
         }
-        return b.run(p.Dir, p.ImportPath, tool("pack"), "grc", mkAbs(objDir, afile), absOfiles)
+        return b.run(p.Dir, p.Dir, p.ImportPath, tool("pack"), "grc", mkAbs(objDir, afile), absOfiles)
 }
 
 func (goToolchain) ld(b *builder, p *Package, out string, allactions []*action, mainpkg string, ofiles []string) error {
         importArgs := b.includeArgs("-L", allactions)
-        return b.run(p.Dir, p.ImportPath, tool(b.arch+"l"), "-o", out, importArgs, mainpkg)
+        return b.run(p.Dir, p.Dir, p.ImportPath, tool(archChar+"l"), "-o", out, importArgs, buildLdflags, mainpkg)
 }
 
 func (goToolchain) cc(b *builder, p *Package, objdir, ofile, cfile string) error {
-        inc := filepath.Join(goroot, "pkg", fmt.Sprintf("%s_%s", b.goos, b.goarch))
+        inc := filepath.Join(goroot, "pkg", fmt.Sprintf("%s_%s", goos, goarch))
         cfile = mkAbs(p.Dir, cfile)
-        return b.run(p.Dir, p.ImportPath, tool(b.arch+"c"), "-FVw",
+        return b.run(p.Dir, p.Dir, p.ImportPath, tool(archChar+"c"), "-FVw",
                 "-I", objdir, "-I", inc, "-o", ofile,
-                "-DGOOS_"+b.goos, "-DGOARCH_"+b.goarch, cfile)
+                "-DGOOS_"+goos, "-DGOARCH_"+goarch, cfile)
 }
 
 // The Gccgo toolchain.
 
-func (gccgoToolchain) gc(b *builder, p *Package, obj string, importArgs []string, gofiles []string) (ofile string, err error) {
+var gccgoBin, _ = exec.LookPath("gccgo")
+
+func (gccgoToolchain) compiler() string {
+        return gccgoBin
+}
+
+func (gccgoToolchain) linker() string {
+        return gccgoBin
+}
+
+func (gccgoToolchain) gc(b *builder, p *Package, obj, dir string, importArgs []string, gofiles []string) (ofile string, err error) {
         out := p.Name + ".o"
         ofile = obj + out
         gcargs := []string{"-g"}
         if p.Name != "main" {
                 if p.fake {
                         gcargs = append(gcargs, "-fgo-prefix=fake_"+p.ImportPath)
                 } else {
                         gcargs = append(gcargs, "-fgo-prefix=go_"+p.ImportPath)
                 }
         }
-        args := stringList("gccgo", importArgs, "-c", b.gcflags, gcargs, "-o", ofile)
+        args := stringList("gccgo", importArgs, "-c", gcargs, "-o", ofile, buildGccgoflags)
         for _, f := range gofiles {
                 args = append(args, mkAbs(p.Dir, f))
         }
-        return ofile, b.run(p.Dir, p.ImportPath, args)
+        return ofile, b.run(dir, p.Dir, p.ImportPath, args)
 }
 
 func (gccgoToolchain) asm(b *builder, p *Package, obj, ofile, sfile string) error {
         sfile = mkAbs(p.Dir, sfile)
-        return b.run(p.Dir, p.ImportPath, "gccgo", "-I", obj, "-o", ofile, "-DGOOS_"+b.goos, "-DGOARCH_"+b.goarch, sfile)
+        return b.run(p.Dir, p.Dir, p.ImportPath, "gccgo", "-I", obj, "-o", ofile, "-DGOOS_"+goos, "-DGOARCH_"+goarch, sfile)
 }
 
-func (gccgoToolchain) pkgpath(basedir string, p *Package) string {
-        afile := filepath.Join(basedir, filepath.FromSlash(p.ImportPath+".a"))
-        // prepend "lib" to the basename
+func (gccgoToolchain) pkgpath(basedir string, p *Package, install bool) string {
+        // NOTE: Apparently gccgo does not distinguish different trees
+        // using goos_goarch, so install is ignored here.
+        afile := filepath.Join(basedir, "gccgo", filepath.FromSlash(p.ImportPath+".a"))
+        // add "lib" to the final element
         return filepath.Join(filepath.Dir(afile), "lib"+filepath.Base(afile))
 }
 
 func (gccgoToolchain) pack(b *builder, p *Package, objDir, afile string, ofiles []string) error {
         var absOfiles []string
         for _, f := range ofiles {
                 absOfiles = append(absOfiles, mkAbs(objDir, f))
         }
-        return b.run(p.Dir, p.ImportPath, "ar", "cru", mkAbs(objDir, afile), absOfiles)
+        return b.run(p.Dir, p.Dir, p.ImportPath, "ar", "cru", mkAbs(objDir, afile), absOfiles)
 }
 
 func (tools gccgoToolchain) ld(b *builder, p *Package, out string, allactions []*action, mainpkg string, ofiles []string) error {
         // gccgo needs explicit linking with all package dependencies,
         // and all LDFLAGS from cgo dependencies
         afiles := []string{}
         ldflags := []string{}
         seen := map[*Package]bool{}
         for _, a := range allactions {
                 if a.p != nil && !seen[a.p] {
                         seen[a.p] = true
                         if !a.p.Standard {
                                 afiles = append(afiles, a.target)
                         }
                         ldflags = append(ldflags, a.p.CgoLDFLAGS...)
                 }
         }
-        return b.run(p.Dir, p.ImportPath, "gccgo", "-o", out, ofiles, "-Wl,-(", afiles, ldflags, "-Wl,-)")
+
+        return b.run(p.Dir, p.Dir, p.ImportPath, "gccgo", "-o", out, buildGccgoflags, ofiles, "-Wl,-(", afiles, ldflags, "-Wl,-)")
 }
 
 func (gccgoToolchain) cc(b *builder, p *Package, objdir, ofile, cfile string) error {
-        inc := filepath.Join(goroot, "pkg", fmt.Sprintf("%s_%s", b.goos, b.goarch))
+        inc := filepath.Join(goroot, "pkg", fmt.Sprintf("%s_%s", goos, goarch))
         cfile = mkAbs(p.Dir, cfile)
-        return b.run(p.Dir, p.ImportPath, "gcc", "-Wall", "-g",
+        return b.run(p.Dir, p.Dir, p.ImportPath, "gcc", "-Wall", "-g",
                 "-I", objdir, "-I", inc, "-o", ofile,
-                "-DGOOS_"+b.goos, "-DGOARCH_"+b.goarch, "-c", cfile)
+                "-DGOOS_"+goos, "-DGOARCH_"+goarch, "-c", cfile)
 }
 
 // gcc runs the gcc C compiler to create an object from a single C file.
 func (b *builder) gcc(p *Package, out string, flags []string, cfile string) error {
         cfile = mkAbs(p.Dir, cfile)
-        return b.run(p.Dir, p.ImportPath, b.gccCmd(p.Dir), flags, "-o", out, "-c", cfile)
+        return b.run(p.Dir, p.Dir, p.ImportPath, b.gccCmd(p.Dir), flags, "-o", out, "-c", cfile)
 }
 
 // gccld runs the gcc linker to create an executable from a set of object files
 func (b *builder) gccld(p *Package, out string, flags []string, obj []string) error {
-        return b.run(p.Dir, p.ImportPath, b.gccCmd(p.Dir), "-o", out, obj, flags)
+        return b.run(p.Dir, p.Dir, p.ImportPath, b.gccCmd(p.Dir), "-o", out, obj, flags)
 }
 
 // gccCmd returns a gcc command line prefix
 func (b *builder) gccCmd(objdir string) []string {
         // TODO: HOST_CC?
         a := []string{"gcc", "-I", objdir, "-g", "-O2"}
 
         // Definitely want -fPIC but on Windows gcc complains
         // "-fPIC ignored for target (all code is position independent)"
-        if b.goos != "windows" {
+        if goos != "windows" {
                 a = append(a, "-fPIC")
         }
-        switch b.arch {
+        switch archChar {
         case "8":
                 a = append(a, "-m32")
         case "6":
                 a = append(a, "-m64")
         }
         // gcc-4.5 and beyond require explicit "-pthread" flag
         // for multithreading with pthread library.
         if buildContext.CgoEnabled {
-                switch b.goos {
+                switch goos {
                 case "windows":
                         a = append(a, "-mthreads")
                 default:
                         a = append(a, "-pthread")
                 }
         }
         return a
 }
 
 func envList(key string) []string {
         return strings.Fields(os.Getenv(key))
 }
 
 var cgoRe = regexp.MustCompile(`[/\\:]`)
 
 func (b *builder) cgo(p *Package, cgoExe, obj string, gccfiles []string) (outGo, outObj []string, err error) {
-        if b.goos != toolGOOS {
+        if goos != toolGOOS {
                 return nil, nil, errors.New("cannot use cgo when compiling for a different operating system")
         }
 
-        cgoCFLAGS := stringList(envList("CGO_CFLAGS"), p.info.CgoCFLAGS)
-        cgoLDFLAGS := stringList(envList("CGO_LDFLAGS"), p.info.CgoLDFLAGS)
+        cgoCFLAGS := stringList(envList("CGO_CFLAGS"), p.CgoCFLAGS)
+        cgoLDFLAGS := stringList(envList("CGO_LDFLAGS"), p.CgoLDFLAGS)
 
-        if pkgs := p.info.CgoPkgConfig; len(pkgs) > 0 {
+        if pkgs := p.CgoPkgConfig; len(pkgs) > 0 {
                 out, err := b.runOut(p.Dir, p.ImportPath, "pkg-config", "--cflags", pkgs)
                 if err != nil {
                         b.showOutput(p.Dir, "pkg-config --cflags "+strings.Join(pkgs, " "), string(out))
                         b.print(err.Error() + "\n")
                         return nil, nil, errPrintedOutput
                 }
                 if len(out) > 0 {
                         cgoCFLAGS = append(cgoCFLAGS, strings.Fields(string(out))...)
                 }
                 out, err = b.runOut(p.Dir, p.ImportPath, "pkg-config", "--libs", pkgs)
@@ skipping 23 matching lines @@
 
         cgoflags := []string{}
         // TODO: make cgo not depend on $GOARCH?
 
         if p.Standard && p.ImportPath == "runtime/cgo" {
                 cgoflags = append(cgoflags, "-import_runtime_cgo=false")
         }
         if _, ok := buildToolchain.(gccgoToolchain); ok {
                 cgoflags = append(cgoflags, "-gccgo")
         }
-        if err := b.run(p.Dir, p.ImportPath, cgoExe, "-objdir", obj, cgoflags, "--", cgoCFLAGS, p.CgoFiles); err != nil {
+        if err := b.run(p.Dir, p.Dir, p.ImportPath, cgoExe, "-objdir", obj, cgoflags, "--", cgoCFLAGS, p.CgoFiles); err != nil {
                 return nil, nil, err
         }
         outGo = append(outGo, gofiles...)
 
         // cc _cgo_defun.c
-        defunObj := obj + "_cgo_defun." + b.arch
+        defunObj := obj + "_cgo_defun." + archChar
         if err := buildToolchain.cc(b, p, obj, defunObj, defunC); err != nil {
                 return nil, nil, err
         }
         outObj = append(outObj, defunObj)
 
         // gcc
         var linkobj []string
         for _, cfile := range cfiles {
                 ofile := obj + cfile[:len(cfile)-1] + "o"
                 if err := b.gcc(p, ofile, cgoCFLAGS, obj+cfile); err != nil {
@@ skipping 17 matching lines @@
                 return nil, nil, err
         }
 
         if _, ok := buildToolchain.(gccgoToolchain); ok {
                 // we don't use dynimport when using gccgo.
                 return outGo, outObj, nil
         }
 
         // cgo -dynimport
         importC := obj + "_cgo_import.c"
-        if err := b.run(p.Dir, p.ImportPath, cgoExe, "-objdir", obj, "-dynimport", dynobj, "-dynout", importC); err != nil {
+        if err := b.run(p.Dir, p.Dir, p.ImportPath, cgoExe, "-objdir", obj, "-dynimport", dynobj, "-dynout", importC); err != nil {
                 return nil, nil, err
         }
 
         // cc _cgo_import.ARCH
-        importObj := obj + "_cgo_import." + b.arch
+        importObj := obj + "_cgo_import." + archChar
         if err := buildToolchain.cc(b, p, obj, importObj, importC); err != nil {
                 return nil, nil, err
         }
 
         // NOTE(rsc): The importObj is a 5c/6c/8c object and on Windows
         // must be processed before the gcc-generated objects.
         // Put it first.  http://golang.org/issue/2601
         outObj = append([]string{importObj}, outObj...)
 
         return outGo, outObj, nil
@@ skipping 14 matching lines @@
         return x
 }
 
 func (q *actionQueue) push(a *action) {
         heap.Push(q, a)
 }
 
 func (q *actionQueue) pop() *action {
         return heap.Pop(q).(*action)
 }