src/cmd/go/build.go - go - Git at Google

 // 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"
 	"fmt"
 	"go/build"
 	"io"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"regexp"
 	"runtime"
 	"strings"
 )

 // Break init cycles
 func init() {
 	cmdBuild.Run = runBuild
 	cmdInstall.Run = runInstall
 }

 var cmdBuild = &Command{
 	UsageLine: "build [-a] [-n] [-v] [importpath... | gofiles...]",
 	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 compiles them into
 a package object or command executable named for the first
 source file.

 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 commands.

 For more about import paths, see 'go help importpath'.

 See also: go install, go get, go clean.
 	`,
 }

 var buildA = cmdBuild.Flag.Bool("a", false, "")
 var buildN = cmdBuild.Flag.Bool("n", false, "")
 var buildV = cmdBuild.Flag.Bool("v", false, "")

 func runBuild(cmd *Command, args []string) {
 	var b builder
 	b.init(*buildA, *buildN, *buildV)

 	if len(args) > 0 && strings.HasSuffix(args[0], ".go") {
 		b.do(b.action(modeInstall, modeBuild, goFilesPackage(args, "")))
 		return
 	}

 	a := &action{f: (*builder).nop}
 	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] [-v] [importpath...]",
 	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 commands.

 For more about import paths, see 'go help importpath'.

 See also: go build, go get, go clean.
 	`,
 }

 var installA = cmdInstall.Flag.Bool("a", false, "")
 var installN = cmdInstall.Flag.Bool("n", false, "")
 var installV = cmdInstall.Flag.Bool("v", false, "")

 func runInstall(cmd *Command, args []string) {
 	var b builder
 	b.init(*installA, *installN, *installV)
 	a := &action{f: (*builder).nop}
 	for _, p := range packages(args) {
 		a.deps = append(a.deps, b.action(modeInstall, modeInstall, p))
 	}
 	b.do(a)
 }

 // 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.
 type builder struct {
 	work        string               // the temporary work directory (ends in filepath.Separator)
 	aflag       bool                 // the -a flag
 	nflag       bool                 // the -n flag
 	vflag       bool                 // the -v flag
 	arch        string               // e.g., "6"
 	actionCache map[cacheKey]*action // a cache of already-constructed actions
 }

 // An action represents a single action in the action graph.
 type action struct {
 	f func(*builder, *action) error // the action itself

 	p      *Package  // the package this action works on
 	deps   []*action // actions that must happen before this one
 	done   bool      // whether the action is done (might have failed)
 	failed bool      // whether the action failed

 	// Results left for communication with other code.
 	pkgobj string // the built .a file
 	pkgbin string // the built a.out file, if one exists
 }

 // cacheKey is the key for the action cache.
 type cacheKey struct {
 	mode buildMode
 	p    *Package
 }

 // buildMode specifies the build mode:
 // are we just building things or also installing the results?
 type buildMode int

 const (
 	modeBuild buildMode = iota
 	modeInstall
 )

 func (b *builder) init(aflag, nflag, vflag bool) {
 	var err error
 	b.aflag = aflag
 	b.nflag = nflag
 	b.vflag = vflag
 	b.actionCache = make(map[cacheKey]*action)

 	b.arch, err = build.ArchChar(build.DefaultContext.GOARCH)
 	if err != nil {
 		fatalf("%s", err)
 	}

 	if nflag {
 		b.work = "$WORK"
 	} else {
 		b.work, err = ioutil.TempDir("", "go-build")
 		if err != nil {
 			fatalf("%s", err)
 		}
 		if vflag {
 			fmt.Printf("WORK=%s\n", b.work)
 		}
 		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
 // package p or named after the first Go file for package main.
 func goFilesPackage(gofiles []string, target string) *Package {
 	// Synthesize fake "directory" that only shows those two files,
 	// to make it look like this is a standard package or
 	// command directory.
 	var dir []os.FileInfo
 	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)
 	}
 	ctxt := build.DefaultContext
 	ctxt.ReadDir = func(string) ([]os.FileInfo, error) { return dir, nil }
 	pwd, _ := os.Getwd()
 	pkg, err := scanPackage(&ctxt, &build.Tree{Path: "."}, "<command line>", "<command line>", pwd)
 	if err != nil {
 		fatalf("%s", err)
 	}
 	if target != "" {
 		pkg.targ = target
 	} else if pkg.Name == "main" {
 		pkg.targ = gofiles[0][:len(gofiles[0])-len(".go")]
 	} else {
 		pkg.targ = pkg.Name + ".a"
 	}
 	pkg.ImportPath = "_/" + pkg.targ
 	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}
 	b.actionCache[key] = a

 	switch mode {
 	case modeBuild, modeInstall:
 		if !needInstall(p) && !b.aflag {
 			a.f = (*builder).nop
 			return a
 		}
 		if p.Standard {
 			switch p.ImportPath {
 			case "runtime", "runtime/cgo":
 				// Too complex - can't build.
 				a.f = (*builder).nop
 				return a
 			case "builtin", "unsafe":
 				// Fake packages - nothing to build.
 				a.f = (*builder).nop
 				return a
 			}
 		}

 		if mode == modeInstall {
 			a.f = (*builder).install
 			a.deps = []*action{b.action(modeBuild, depMode, p)}
 			return a
 		}

 		a.f = (*builder).build
 		for _, p1 := range p.imports {
 			a.deps = append(a.deps, b.action(depMode, depMode, p1))
 		}
 	}

 	return a
 }

 // needInstall reports whether p needs to be built and installed.
 // That is only true if some source file is newer than the installed package binary.
 func needInstall(p *Package) bool {
 	if p.targ == "" {
 		return true
 	}
 	fi, err := os.Stat(p.targ)
 	if err != nil {
 		return true
 	}
 	t := fi.ModTime()

 	srcss := [][]string{
 		p.GoFiles,
 		p.CFiles,
 		p.SFiles,
 		p.CgoFiles,
 	}
 	for _, srcs := range srcss {
 		for _, src := range srcs {
 			fi, err := os.Stat(filepath.Join(p.Dir, src))
 			if err != nil {
 				return true
 			}
 			if fi.ModTime().After(t) {
 				return true
 			}
 		}
 	}

 	return false
 }

 // do runs the action graph rooted at a.
 func (b *builder) do(a *action) {
 	if a.done {
 		return
 	}
 	for _, a1 := range a.deps {
 		b.do(a1)
 		if a1.failed {
 			a.failed = true
 			a.done = true
 			return
 		}
 	}
 	if err := a.f(b, a); err != nil {
 		errorf("%s", err)
 		a.failed = true
 	}
 	a.done = true
 }

 func (b *builder) nop(a *action) error {
 	return nil
 }

 // build is the action for building a single package.
 func (b *builder) build(a *action) error {
 	obj := filepath.Join(b.work, filepath.FromSlash(a.p.ImportPath+"/_obj")) + string(filepath.Separator)
 	a.pkgobj = filepath.Join(b.work, filepath.FromSlash(a.p.ImportPath+".a"))

 	// make build directory
 	if err := b.mkdir(obj); err != nil {
 		return err
 	}

 	var objects []string
 	var gofiles []string
 	gofiles = append(gofiles, a.p.GoFiles...)

 	// run cgo
 	if len(a.p.CgoFiles) > 0 {
 		outGo, outObj, err := b.cgo(a.p.Dir, obj, a.p.info)
 		if err != nil {
 			return err
 		}
 		objects = append(objects, outObj...)
 		gofiles = append(gofiles, outGo...)
 	}

 	// prepare Go import path list
 	var inc []string
 	inc = append(inc, "-I", b.work)
 	incMap := map[string]bool{}
 	for _, a1 := range a.deps {
 		p1 := a1.p
 		if p1.t.Goroot {
 			continue
 		}
 		pkgdir := p1.t.PkgDir()
 		if !incMap[pkgdir] {
 			incMap[pkgdir] = true
 			inc = append(inc, "-I", pkgdir)
 		}
 	}

 	// compile Go
 	if len(gofiles) > 0 {
 		out := "_go_.6"
 		if err := b.gc(a.p.Dir, obj+out, a.p.ImportPath, inc, gofiles); err != nil {
 			return err
 		}
 		objects = append(objects, out)
 	}

 	// assemble .s files
 	if len(a.p.SFiles) > 0 {
 		for _, sfile := range a.p.SFiles {
 			out := sfile[:len(sfile)-len(".s")] + "." + b.arch
 			if err := b.asm(a.p.Dir, obj+out, sfile); err != nil {
 				return err
 			}
 			objects = append(objects, out)
 		}
 	}

 	// pack into archive
 	if err := b.gopack(obj, a.pkgobj, objects); err != nil {
 		return err
 	}

 	if a.p.Name == "main" {
 		// command.
 		// import paths for compiler are introduced by -I.
 		// for linker, they are introduced by -L.
 		for i := 0; i < len(inc); i += 2 {
 			inc[i] = "-L"
 		}
 		a.pkgbin = obj + "a.out"
 		if err := b.ld(a.p.Dir, a.pkgbin, inc, a.pkgobj); err != nil {
 			return err
 		}
 	}

 	return nil
 }

 // install is the action for installing a single package.
 func (b *builder) install(a *action) error {
 	if err := b.build(a); err != nil {
 		return err
 	}

 	var src string
 	var perm uint32
 	if a.pkgbin != "" {
 		src = a.pkgbin
 		perm = 0777
 	} else {
 		src = a.pkgobj
 		perm = 0666
 	}

 	// make target directory
 	dst := a.p.targ
 	dir, _ := filepath.Split(dst)
 	if dir != "" {
 		if err := b.mkdir(dir); err != nil {
 			return err
 		}
 	}

 	return b.copyFile(dst, src, perm)
 }

 // copyFile is like 'cp src dst'.
 func (b *builder) copyFile(dst, src string, perm uint32) error {
 	if b.nflag || b.vflag {
 		b.showcmd("cp %s %s", src, dst)
 		if b.nflag {
 			return nil
 		}
 	}

 	sf, err := os.Open(src)
 	if err != nil {
 		return err
 	}
 	defer sf.Close()
 	os.Remove(dst)
 	df, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
 	if err != nil {
 		return err
 	}
 	_, err = io.Copy(df, sf)
 	df.Close()
 	if err != nil {
 		os.Remove(dst)
 		return err
 	}
 	return nil
 }

 // fmtcmd is like fmt.Sprintf but replaces references to the
 // work directory (a temporary directory with a clumsy name)
 // with $WORK.
 func (b *builder) fmtcmd(format string, args ...interface{}) string {
 	s := fmt.Sprintf(format, args...)
 	s = strings.Replace(s, b.work, "$WORK", -1)
 	return s
 }

 // showcmd prints the given command to standard output
 // for the implementation of -n or -v.
 func (b *builder) showcmd(format string, args ...interface{}) {
 	fmt.Println(b.fmtcmd(format, args...))
 }

 // 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, cmdline ...string) error {
 	if b.nflag || b.vflag {
 		b.showcmd("cd %s; %s", dir, strings.Join(cmdline, " "))
 		if b.nflag {
 			return nil
 		}
 	}

 	var buf bytes.Buffer
 	cmd := exec.Command(cmdline[0], cmdline[1:]...)
 	cmd.Stdout = &buf
 	cmd.Stderr = &buf
 	cmd.Dir = dir
 	// TODO: cmd.Env
 	err := cmd.Run()
 	if buf.Len() > 0 {
 		fmt.Fprintf(os.Stderr, "# cd %s; %s\n", dir, strings.Join(cmdline, " "))
 		fmt.Fprintf(os.Stderr, "%s\n", buf.Bytes())
 	}
 	return err
 }

 // mkdir makes the named directory.
 func (b *builder) mkdir(dir string) error {
 	if b.nflag || b.vflag {
 		b.showcmd("mkdir -p %s", dir)
 		if b.nflag {
 			return nil
 		}
 	}

 	if err := os.MkdirAll(dir, 0777); err != nil {
 		return err
 	}
 	return nil
 }

 // gc runs the Go compiler in a specific directory on a set of files
 // to generate the named output file.
 func (b *builder) gc(dir, ofile, importPath string, importArgs []string, gofiles []string) error {
 	args := append([]string{b.arch + "g", "-o", ofile, "-p", importPath}, importArgs...)
 	args = append(args, gofiles...)
 	return b.run(dir, args...)
 }

 // asm runs the assembler in a specific directory on a specific file
 // to generate the named output file.
 func (b *builder) asm(dir, ofile, sfile string) error {
 	return b.run(dir, b.arch+"a", "-o", ofile, sfile)
 }

 // gopack runs the assembler in a specific directory to create
 // an archive from a set of object files.
 // typically it is run in the object directory.
 func (b *builder) gopack(objDir, afile string, ofiles []string) error {
 	return b.run(objDir, append([]string{"gopack", "grc", afile}, ofiles...)...)
 }

 // ld runs the linker to create a package starting at mainpkg.
 func (b *builder) ld(dir, out string, importArgs []string, mainpkg string) error {
 	return b.run(dir, append(append([]string{b.arch + "l", "-o", out}, importArgs...), mainpkg)...)
 }

 // cc runs the gc-toolchain C compiler in a directory on a C file
 // to produce an output file.
 func (b *builder) cc(dir, ofile, cfile string) error {
 	inc := filepath.Join(runtime.GOROOT(), "pkg",
 		fmt.Sprintf("%s_%s", build.DefaultContext.GOOS, build.DefaultContext.GOARCH))
 	return b.run(dir, b.arch+"c", "-FVW", "-I", inc, "-o", ofile, cfile)
 }

 // gcc runs the gcc C compiler to create an object from a single C file.
 func (b *builder) gcc(dir, out string, flags []string, cfile string) error {
 	return b.run(dir, b.gccCmd(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(dir, out string, flags []string, obj []string) error {
 	return b.run(dir, append(b.gccCmd(dir, flags, "-o", out), obj...)...)
 }

 // gccCmd returns a gcc command line ending with args
 func (b *builder) gccCmd(objdir string, flags []string, args ...string) []string {
 	// TODO: HOST_CC?
 	a := []string{"gcc", "-I", objdir, "-g", "-fPIC", "-O2"}
 	switch b.arch {
 	case "8":
 		a = append(a, "-m32")
 	case "6":
 		a = append(a, "-m64")
 	}
 	a = append(a, flags...)
 	return append(a, args...)
 }

 var cgoRe = regexp.MustCompile(`[/\\:]`)

 func (b *builder) cgo(dir, obj string, info *build.DirInfo) (outGo, outObj []string, err error) {
 	// cgo
 	// TODO: CGOPKGPATH, CGO_FLAGS?
 	gofiles := []string{obj + "_cgo_gotypes.go"}
 	cfiles := []string{"_cgo_main.c", "_cgo_export.c"}
 	for _, fn := range info.CgoFiles {
 		f := cgoRe.ReplaceAllString(fn[:len(fn)-2], "_")
 		gofiles = append(gofiles, obj+f+"cgo1.go")
 		cfiles = append(cfiles, f+"cgo2.c")
 	}
 	defunC := obj + "_cgo_defun.c"
 	// TODO: make cgo not depend on $GOARCH?
 	// TODO: make cgo write to obj
 	if err := b.run(dir, append([]string{"cgo", "-objdir", obj, "--"}, info.CgoFiles...)...); err != nil {
 		return nil, nil, err
 	}
 	outGo = append(outGo, gofiles...)

 	// cc _cgo_defun.c
 	defunObj := obj + "_cgo_defun." + b.arch
 	if err := b.cc(dir, 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(dir, ofile, info.CgoCFLAGS, obj+cfile); err != nil {
 			return nil, nil, err
 		}
 		linkobj = append(linkobj, ofile)
 		if !strings.HasSuffix(ofile, "_cgo_main.o") {
 			outObj = append(outObj, ofile)
 		}
 	}
 	for _, cfile := range info.CFiles {
 		ofile := obj + cgoRe.ReplaceAllString(cfile[:len(cfile)-1], "_") + "o"
 		if err := b.gcc(dir, ofile, info.CgoCFLAGS, cfile); err != nil {
 			return nil, nil, err
 		}
 		linkobj = append(linkobj, ofile)
 		outObj = append(outObj, ofile)
 	}
 	dynobj := obj + "_cgo_.o"
 	if err := b.gccld(dir, dynobj, info.CgoLDFLAGS, linkobj); err != nil {
 		return nil, nil, err
 	}

 	// cgo -dynimport
 	importC := obj + "_cgo_import.c"
 	if err := b.run(dir, "cgo", "-objdir", obj, "-dynimport", dynobj, "-dynout", importC); err != nil {
 		return nil, nil, err
 	}

 	// cc _cgo_import.ARCH
 	importObj := obj + "_cgo_import." + b.arch
 	if err := b.cc(dir, importObj, importC); err != nil {
 		return nil, nil, err
 	}
 	outObj = append(outObj, importObj)

 	return outGo, outObj, nil
 }
	// 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"
	"fmt"
	"go/build"
	"io"
	"io/ioutil"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"runtime"
	"strings"
	)

	// Break init cycles
	func init() {
	cmdBuild.Run = runBuild
	cmdInstall.Run = runInstall
	}

	var cmdBuild = &Command{
	UsageLine: "build [-a] [-n] [-v] [importpath... \| gofiles...]",
	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 compiles them into
	a package object or command executable named for the first
	source file.

	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 commands.

	For more about import paths, see 'go help importpath'.

	See also: go install, go get, go clean.
	`,
	}

	var buildA = cmdBuild.Flag.Bool("a", false, "")
	var buildN = cmdBuild.Flag.Bool("n", false, "")
	var buildV = cmdBuild.Flag.Bool("v", false, "")

	func runBuild(cmd *Command, args []string) {
	var b builder
	b.init(buildA, buildN, *buildV)

	if len(args) > 0 && strings.HasSuffix(args[0], ".go") {
	b.do(b.action(modeInstall, modeBuild, goFilesPackage(args, "")))
	return
	}

	a := &action{f: (*builder).nop}
	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] [-v] [importpath...]",
	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 commands.

	For more about import paths, see 'go help importpath'.

	See also: go build, go get, go clean.
	`,
	}

	var installA = cmdInstall.Flag.Bool("a", false, "")
	var installN = cmdInstall.Flag.Bool("n", false, "")
	var installV = cmdInstall.Flag.Bool("v", false, "")

	func runInstall(cmd *Command, args []string) {
	var b builder
	b.init(installA, installN, *installV)
	a := &action{f: (*builder).nop}
	for _, p := range packages(args) {
	a.deps = append(a.deps, b.action(modeInstall, modeInstall, p))
	}
	b.do(a)
	}

	// 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.
	type builder struct {
	work string // the temporary work directory (ends in filepath.Separator)
	aflag bool // the -a flag
	nflag bool // the -n flag
	vflag bool // the -v flag
	arch string // e.g., "6"
	actionCache map[cacheKey]*action // a cache of already-constructed actions
	}

	// An action represents a single action in the action graph.
	type action struct {
	f func(builder, action) error // the action itself

	p *Package // the package this action works on
	deps []*action // actions that must happen before this one
	done bool // whether the action is done (might have failed)
	failed bool // whether the action failed

	// Results left for communication with other code.
	pkgobj string // the built .a file
	pkgbin string // the built a.out file, if one exists
	}

	// cacheKey is the key for the action cache.
	type cacheKey struct {
	mode buildMode
	p *Package
	}

	// buildMode specifies the build mode:
	// are we just building things or also installing the results?
	type buildMode int

	const (
	modeBuild buildMode = iota
	modeInstall
	)

	func (b *builder) init(aflag, nflag, vflag bool) {
	var err error
	b.aflag = aflag
	b.nflag = nflag
	b.vflag = vflag
	b.actionCache = make(map[cacheKey]*action)

	b.arch, err = build.ArchChar(build.DefaultContext.GOARCH)
	if err != nil {
	fatalf("%s", err)
	}

	if nflag {
	b.work = "$WORK"
	} else {
	b.work, err = ioutil.TempDir("", "go-build")
	if err != nil {
	fatalf("%s", err)
	}
	if vflag {
	fmt.Printf("WORK=%s\n", b.work)
	}
	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
	// package p or named after the first Go file for package main.
	func goFilesPackage(gofiles []string, target string) *Package {
	// Synthesize fake "directory" that only shows those two files,
	// to make it look like this is a standard package or
	// command directory.
	var dir []os.FileInfo
	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)
	}
	ctxt := build.DefaultContext
	ctxt.ReadDir = func(string) ([]os.FileInfo, error) { return dir, nil }
	pwd, _ := os.Getwd()
	pkg, err := scanPackage(&ctxt, &build.Tree{Path: "."}, "<command line>", "<command line>", pwd)
	if err != nil {
	fatalf("%s", err)
	}
	if target != "" {
	pkg.targ = target
	} else if pkg.Name == "main" {
	pkg.targ = gofiles[0][:len(gofiles[0])-len(".go")]
	} else {
	pkg.targ = pkg.Name + ".a"
	}
	pkg.ImportPath = "_/" + pkg.targ
	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}
	b.actionCache[key] = a

	switch mode {
	case modeBuild, modeInstall:
	if !needInstall(p) && !b.aflag {
	a.f = (*builder).nop
	return a
	}
	if p.Standard {
	switch p.ImportPath {
	case "runtime", "runtime/cgo":
	// Too complex - can't build.
	a.f = (*builder).nop
	return a
	case "builtin", "unsafe":
	// Fake packages - nothing to build.
	a.f = (*builder).nop
	return a
	}
	}

	if mode == modeInstall {
	a.f = (*builder).install
	a.deps = []*action{b.action(modeBuild, depMode, p)}
	return a
	}

	a.f = (*builder).build
	for _, p1 := range p.imports {
	a.deps = append(a.deps, b.action(depMode, depMode, p1))
	}
	}

	return a
	}

	// needInstall reports whether p needs to be built and installed.
	// That is only true if some source file is newer than the installed package binary.
	func needInstall(p *Package) bool {
	if p.targ == "" {
	return true
	}
	fi, err := os.Stat(p.targ)
	if err != nil {
	return true
	}
	t := fi.ModTime()

	srcss := [][]string{
	p.GoFiles,
	p.CFiles,
	p.SFiles,
	p.CgoFiles,
	}
	for _, srcs := range srcss {
	for _, src := range srcs {
	fi, err := os.Stat(filepath.Join(p.Dir, src))
	if err != nil {
	return true
	}
	if fi.ModTime().After(t) {
	return true
	}
	}
	}

	return false
	}

	// do runs the action graph rooted at a.
	func (b builder) do(a action) {
	if a.done {
	return
	}
	for _, a1 := range a.deps {
	b.do(a1)
	if a1.failed {
	a.failed = true
	a.done = true
	return
	}
	}
	if err := a.f(b, a); err != nil {
	errorf("%s", err)
	a.failed = true
	}
	a.done = true
	}

	func (b builder) nop(a action) error {
	return nil
	}

	// build is the action for building a single package.
	func (b builder) build(a action) error {
	obj := filepath.Join(b.work, filepath.FromSlash(a.p.ImportPath+"/_obj")) + string(filepath.Separator)
	a.pkgobj = filepath.Join(b.work, filepath.FromSlash(a.p.ImportPath+".a"))

	// make build directory
	if err := b.mkdir(obj); err != nil {
	return err
	}

	var objects []string
	var gofiles []string
	gofiles = append(gofiles, a.p.GoFiles...)

	// run cgo
	if len(a.p.CgoFiles) > 0 {
	outGo, outObj, err := b.cgo(a.p.Dir, obj, a.p.info)
	if err != nil {
	return err
	}
	objects = append(objects, outObj...)
	gofiles = append(gofiles, outGo...)
	}

	// prepare Go import path list
	var inc []string
	inc = append(inc, "-I", b.work)
	incMap := map[string]bool{}
	for _, a1 := range a.deps {
	p1 := a1.p
	if p1.t.Goroot {
	continue
	}
	pkgdir := p1.t.PkgDir()
	if !incMap[pkgdir] {
	incMap[pkgdir] = true
	inc = append(inc, "-I", pkgdir)
	}
	}

	// compile Go
	if len(gofiles) > 0 {
	out := "_go_.6"
	if err := b.gc(a.p.Dir, obj+out, a.p.ImportPath, inc, gofiles); err != nil {
	return err
	}
	objects = append(objects, out)
	}

	// assemble .s files
	if len(a.p.SFiles) > 0 {
	for _, sfile := range a.p.SFiles {
	out := sfile[:len(sfile)-len(".s")] + "." + b.arch
	if err := b.asm(a.p.Dir, obj+out, sfile); err != nil {
	return err
	}
	objects = append(objects, out)
	}
	}

	// pack into archive
	if err := b.gopack(obj, a.pkgobj, objects); err != nil {
	return err
	}

	if a.p.Name == "main" {
	// command.
	// import paths for compiler are introduced by -I.
	// for linker, they are introduced by -L.
	for i := 0; i < len(inc); i += 2 {
	inc[i] = "-L"
	}
	a.pkgbin = obj + "a.out"
	if err := b.ld(a.p.Dir, a.pkgbin, inc, a.pkgobj); err != nil {
	return err
	}
	}

	return nil
	}

	// install is the action for installing a single package.
	func (b builder) install(a action) error {
	if err := b.build(a); err != nil {
	return err
	}

	var src string
	var perm uint32
	if a.pkgbin != "" {
	src = a.pkgbin
	perm = 0777
	} else {
	src = a.pkgobj
	perm = 0666
	}

	// make target directory
	dst := a.p.targ
	dir, _ := filepath.Split(dst)
	if dir != "" {
	if err := b.mkdir(dir); err != nil {
	return err
	}
	}

	return b.copyFile(dst, src, perm)
	}

	// copyFile is like 'cp src dst'.
	func (b *builder) copyFile(dst, src string, perm uint32) error {
	if b.nflag \|\| b.vflag {
	b.showcmd("cp %s %s", src, dst)
	if b.nflag {
	return nil
	}
	}

	sf, err := os.Open(src)
	if err != nil {
	return err
	}
	defer sf.Close()
	os.Remove(dst)
	df, err := os.OpenFile(dst, os.O_WRONLY\|os.O_CREATE\|os.O_TRUNC, perm)
	if err != nil {
	return err
	}
	_, err = io.Copy(df, sf)
	df.Close()
	if err != nil {
	os.Remove(dst)
	return err
	}
	return nil
	}

	// fmtcmd is like fmt.Sprintf but replaces references to the
	// work directory (a temporary directory with a clumsy name)
	// with $WORK.
	func (b *builder) fmtcmd(format string, args ...interface{}) string {
	s := fmt.Sprintf(format, args...)
	s = strings.Replace(s, b.work, "$WORK", -1)
	return s
	}

	// showcmd prints the given command to standard output
	// for the implementation of -n or -v.
	func (b *builder) showcmd(format string, args ...interface{}) {
	fmt.Println(b.fmtcmd(format, args...))
	}

	// 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, cmdline ...string) error {
	if b.nflag \|\| b.vflag {
	b.showcmd("cd %s; %s", dir, strings.Join(cmdline, " "))
	if b.nflag {
	return nil
	}
	}

	var buf bytes.Buffer
	cmd := exec.Command(cmdline[0], cmdline[1:]...)
	cmd.Stdout = &buf
	cmd.Stderr = &buf
	cmd.Dir = dir
	// TODO: cmd.Env
	err := cmd.Run()
	if buf.Len() > 0 {
	fmt.Fprintf(os.Stderr, "# cd %s; %s\n", dir, strings.Join(cmdline, " "))
	fmt.Fprintf(os.Stderr, "%s\n", buf.Bytes())
	}
	return err
	}

	// mkdir makes the named directory.
	func (b *builder) mkdir(dir string) error {
	if b.nflag \|\| b.vflag {
	b.showcmd("mkdir -p %s", dir)
	if b.nflag {
	return nil
	}
	}

	if err := os.MkdirAll(dir, 0777); err != nil {
	return err
	}
	return nil
	}

	// gc runs the Go compiler in a specific directory on a set of files
	// to generate the named output file.
	func (b *builder) gc(dir, ofile, importPath string, importArgs []string, gofiles []string) error {
	args := append([]string{b.arch + "g", "-o", ofile, "-p", importPath}, importArgs...)
	args = append(args, gofiles...)
	return b.run(dir, args...)
	}

	// asm runs the assembler in a specific directory on a specific file
	// to generate the named output file.
	func (b *builder) asm(dir, ofile, sfile string) error {
	return b.run(dir, b.arch+"a", "-o", ofile, sfile)
	}

	// gopack runs the assembler in a specific directory to create
	// an archive from a set of object files.
	// typically it is run in the object directory.
	func (b *builder) gopack(objDir, afile string, ofiles []string) error {
	return b.run(objDir, append([]string{"gopack", "grc", afile}, ofiles...)...)
	}

	// ld runs the linker to create a package starting at mainpkg.
	func (b *builder) ld(dir, out string, importArgs []string, mainpkg string) error {
	return b.run(dir, append(append([]string{b.arch + "l", "-o", out}, importArgs...), mainpkg)...)
	}

	// cc runs the gc-toolchain C compiler in a directory on a C file
	// to produce an output file.
	func (b *builder) cc(dir, ofile, cfile string) error {
	inc := filepath.Join(runtime.GOROOT(), "pkg",
	fmt.Sprintf("%s_%s", build.DefaultContext.GOOS, build.DefaultContext.GOARCH))
	return b.run(dir, b.arch+"c", "-FVW", "-I", inc, "-o", ofile, cfile)
	}

	// gcc runs the gcc C compiler to create an object from a single C file.
	func (b *builder) gcc(dir, out string, flags []string, cfile string) error {
	return b.run(dir, b.gccCmd(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(dir, out string, flags []string, obj []string) error {
	return b.run(dir, append(b.gccCmd(dir, flags, "-o", out), obj...)...)
	}

	// gccCmd returns a gcc command line ending with args
	func (b *builder) gccCmd(objdir string, flags []string, args ...string) []string {
	// TODO: HOST_CC?
	a := []string{"gcc", "-I", objdir, "-g", "-fPIC", "-O2"}
	switch b.arch {
	case "8":
	a = append(a, "-m32")
	case "6":
	a = append(a, "-m64")
	}
	a = append(a, flags...)
	return append(a, args...)
	}

	var cgoRe = regexp.MustCompile(`[/\\:]`)

	func (b builder) cgo(dir, obj string, info build.DirInfo) (outGo, outObj []string, err error) {
	// cgo
	// TODO: CGOPKGPATH, CGO_FLAGS?
	gofiles := []string{obj + "_cgo_gotypes.go"}
	cfiles := []string{"_cgo_main.c", "_cgo_export.c"}
	for _, fn := range info.CgoFiles {
	f := cgoRe.ReplaceAllString(fn[:len(fn)-2], "_")
	gofiles = append(gofiles, obj+f+"cgo1.go")
	cfiles = append(cfiles, f+"cgo2.c")
	}
	defunC := obj + "_cgo_defun.c"
	// TODO: make cgo not depend on $GOARCH?
	// TODO: make cgo write to obj
	if err := b.run(dir, append([]string{"cgo", "-objdir", obj, "--"}, info.CgoFiles...)...); err != nil {
	return nil, nil, err
	}
	outGo = append(outGo, gofiles...)

	// cc _cgo_defun.c
	defunObj := obj + "_cgo_defun." + b.arch
	if err := b.cc(dir, 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(dir, ofile, info.CgoCFLAGS, obj+cfile); err != nil {
	return nil, nil, err
	}
	linkobj = append(linkobj, ofile)
	if !strings.HasSuffix(ofile, "_cgo_main.o") {
	outObj = append(outObj, ofile)
	}
	}
	for _, cfile := range info.CFiles {
	ofile := obj + cgoRe.ReplaceAllString(cfile[:len(cfile)-1], "_") + "o"
	if err := b.gcc(dir, ofile, info.CgoCFLAGS, cfile); err != nil {
	return nil, nil, err
	}
	linkobj = append(linkobj, ofile)
	outObj = append(outObj, ofile)
	}
	dynobj := obj + "_cgo_.o"
	if err := b.gccld(dir, dynobj, info.CgoLDFLAGS, linkobj); err != nil {
	return nil, nil, err
	}

	// cgo -dynimport
	importC := obj + "_cgo_import.c"
	if err := b.run(dir, "cgo", "-objdir", obj, "-dynimport", dynobj, "-dynout", importC); err != nil {
	return nil, nil, err
	}

	// cc _cgo_import.ARCH
	importObj := obj + "_cgo_import." + b.arch
	if err := b.cc(dir, importObj, importC); err != nil {
	return nil, nil, err
	}
	outObj = append(outObj, importObj)

	return outGo, outObj, nil
	}