code review 5645093: cmd/dist: cross-compiling 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"
@@ skipping 329 matching lines @@
         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 len(p.CgoFiles) > 0 {
-                var stk importStack
-                p1 := loadPackage("cmd/cgo", &stk)
-                if p1.Error != nil {
-                        fatalf("load cmd/cgo: %v", p1.Error)
+        // 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 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)
                 }
-                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 {
@@ skipping 192 matching lines @@
                                 return nongcc, gcc
                         }
                         cfiles, gccfiles = filter(cfiles, cfiles[:0], gccfiles)
                         sfiles, gccfiles = filter(sfiles, sfiles[:0], gccfiles)
                 } else {
                         gccfiles = append(cfiles, sfiles...)
                         cfiles = nil
                         sfiles = nil
                 }
 
-                outGo, outObj, err := b.cgo(a.p, a.cgo.target, obj, gccfiles)
+                cgoExe := tool("cgo")
+                if a.cgo != nil {
+                        cgoExe = a.cgo.target
+                }
+                outGo, outObj, err := b.cgo(a.p, cgoExe, obj, gccfiles)
                 if err != nil {
                         return err
                 }
                 cgoObjects = append(cgoObjects, outObj...)
                 gofiles = append(gofiles, outGo...)
         }
 
         // Prepare Go import path list.
         inc := b.includeArgs("-I", a.deps)
 
@@ skipping 681 matching lines @@
         return x
 }
 
 func (q *actionQueue) push(a *action) {
         heap.Push(q, a)
 }
 
 func (q *actionQueue) pop() *action {
         return heap.Pop(q).(*action)
 }