var BuildToolchain toolchain = noToolchain{}
var CmdBuild = &base.Command{ UsageLine: "go build [-o output] [-i] [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 to build are a list of .go files from a single directory, build treats them as a list of source files specifying a single package. When compiling packages, build ignores files that end in '_test.go'. When compiling a single main package, build writes the resulting executable to an output file named after the first source file ('go build ed.go rx.go' writes 'ed' or 'ed.exe') or the source code directory ('go build unix/sam' writes 'sam' or 'sam.exe'). The '.exe' suffix is added when writing a Windows executable. When compiling multiple packages or a single non-main package, build compiles the packages but discards the resulting object, serving only as a check that the packages can be built. The -o flag forces build to write the resulting executable or object to the named output file or directory, instead of the default behavior described in the last two paragraphs. If the named output is a directory that exists, then any resulting executables will be written to that directory. The -i flag installs the packages that are dependencies of the target. The build flags are shared by the build, clean, get, install, list, run, and test commands: -a force rebuilding of packages that are already up-to-date. -n print the commands but do not run them. -p n the number of programs, such as build commands or test binaries, that can be run in parallel. The default is the number of CPUs available. -race enable data race detection. Supported only on linux/amd64, freebsd/amd64, darwin/amd64 and windows/amd64. -msan enable interoperation with memory sanitizer. Supported only on linux/amd64, linux/arm64 and only with Clang/LLVM as the host C compiler. -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. -asmflags '[pattern=]arg list' arguments to pass on each go tool asm invocation. -buildmode mode build mode to use. See 'go help buildmode' for more. -compiler name name of compiler to use, as in runtime.Compiler (gccgo or gc). -gccgoflags '[pattern=]arg list' arguments to pass on each gccgo compiler/linker invocation. -gcflags '[pattern=]arg list' arguments to pass on each go tool compile invocation. -installsuffix suffix a suffix to use in the name of the package installation directory, in order to keep output separate from default builds. If using the -race flag, the install suffix is automatically set to race or, if set explicitly, has _race appended to it. Likewise for the -msan flag. Using a -buildmode option that requires non-default compile flags has a similar effect. -ldflags '[pattern=]arg list' arguments to pass on each go tool link invocation. -linkshared link against shared libraries previously created with -buildmode=shared. -mod mode module download mode to use: readonly or vendor. See 'go help modules' for more. -pkgdir dir install and load all packages from dir instead of the usual locations. For example, when building with a non-standard configuration, use -pkgdir to keep generated packages in a separate location. -tags tag,list a comma-separated list of build tags to consider satisfied during the build. For more information about build tags, see the description of build constraints in the documentation for the go/build package. (Earlier versions of Go used a space-separated list, and that form is deprecated but still recognized.) -trimpath remove all file system paths from the resulting executable. Instead of absolute file system paths, the recorded file names will begin with either "go" (for the standard library), or a module path@version (when using modules), or a plain import path (when using GOPATH). -toolexec 'cmd args' a program to use to invoke toolchain programs like vet and asm. For example, instead of running asm, the go command will run 'cmd args /path/to/asm <arguments for asm>'. The -asmflags, -gccgoflags, -gcflags, and -ldflags flags accept a space-separated list of arguments to pass to an underlying tool during the build. To embed spaces in an element in the list, surround it with either single or double quotes. The argument list may be preceded by a package pattern and an equal sign, which restricts the use of that argument list to the building of packages matching that pattern (see 'go help packages' for a description of package patterns). Without a pattern, the argument list applies only to the packages named on the command line. The flags may be repeated with different patterns in order to specify different arguments for different sets of packages. If a package matches patterns given in multiple flags, the latest match on the command line wins. For example, 'go build -gcflags=-S fmt' prints the disassembly only for package fmt, while 'go build -gcflags=all=-S fmt' prints the disassembly for fmt and all its dependencies. For more about specifying packages, see 'go help packages'. For more about where packages and binaries are installed, run 'go help gopath'. For more about calling between Go and C/C++, run 'go help c'. Note: Build adheres to certain conventions such as those described by 'go help gopath'. Not all projects can follow these conventions, however. Installations that have their own conventions or that use a separate software build system may choose to use lower-level invocations such as 'go tool compile' and 'go tool link' to avoid some of the overheads and design decisions of the build tool. See also: go install, go get, go clean. `, }
var CmdInstall = &base.Command{ UsageLine: "go install [-i] [build flags] [packages]", Short: "compile and install packages and dependencies", Long: ` Install compiles and installs the packages named by the import paths. Executables are installed in the directory named by the GOBIN environment variable, which defaults to $GOPATH/bin or $HOME/go/bin if the GOPATH environment variable is not set. Executables in $GOROOT are installed in $GOROOT/bin or $GOTOOLDIR instead of $GOBIN. When module-aware mode is disabled, other packages are installed in the directory $GOPATH/pkg/$GOOS_$GOARCH. When module-aware mode is enabled, other packages are built and cached but not installed. The -i flag installs the dependencies of the named packages as well. 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. `, }
var ExecCmd []string
ExecCmd is the command to use to run user binaries. Normally it is empty, meaning run the binaries directly. If cross-compiling and running on a remote system or simulator, it is typically go_GOOS_GOARCH_exec, with the target GOOS and GOARCH substituted. The -exec flag overrides these defaults.
var GccgoName, GccgoBin string
var VetExplicit bool
VetExplicit records whether the vet flags were set explicitly on the command line.
var VetFlags []string
VetFlags are the default flags to pass to vet. The caller is expected to set them before executing any vet actions.
var VetTool string
VetTool is the path to an alternate vet tool binary. The caller is expected to set it (if needed) before executing any vet actions.
func AddBuildFlags(cmd *base.Command)
addBuildFlags adds the flags common to the build, clean, get, install, list, run, and test commands.
func BuildInit()
func BuildInstallFunc(b *Builder, a *Action) (err error)
BuildInstallFunc is the action for installing a single package or executable.
func FindExecCmd() []string
FindExecCmd derives the value of ExecCmd to use. It returns that value and leaves ExecCmd set for direct use.
func InstallPackages(patterns []string, pkgs []*load.Package)
type Action struct {
Mode string // description of action operation
Package *load.Package // the package this action works on
Deps []*Action // actions that must happen before this one
Func func(*Builder, *Action) error // the action itself (nil = no-op)
IgnoreFail bool // whether to run f even if dependencies fail
TestOutput *bytes.Buffer // test output buffer
Args []string // additional args for runProgram
TryCache func(*Builder, *Action) bool // callback for cache bypass
// Generated files, directories.
Objdir string // directory for intermediate objects
Target string // goal of the action: the created package or executable
VetxOnly bool // Mode=="vet": only being called to supply info about dependencies
Failed bool // whether the action failed
// contains filtered or unexported fields
}
An Action represents a single action in the action graph.
func (a *Action) BuildActionID() string
BuildActionID returns the action ID section of a's build ID.
func (a *Action) BuildContentID() string
BuildContentID returns the content ID section of a's build ID.
func (a *Action) BuildID() string
BuildID returns a's build ID.
func (a *Action) BuiltTarget() string
BuiltTarget returns the actual file that was built. This differs from Target when the result was cached.
type BuildMode int
BuildMode specifies the build mode: are we just building things or also installing the results?
const (
ModeBuild BuildMode = iota
ModeInstall
ModeBuggyInstall
ModeVetOnly = 1 << 8
)
type Builder struct {
WorkDir string // the temporary work directory (ends in filepath.Separator)
Print func(args ...interface{}) (int, error)
IsCmdList bool // running as part of go list; set p.Stale and additional fields below
NeedError bool // list needs p.Error
NeedExport bool // list needs p.Export
NeedCompiledGoFiles bool // list needs p.CompiledGoFIles
// contains filtered or unexported fields
}
A Builder holds global state about a build. It does not hold per-package state, because we build packages in parallel, and the builder is shared.
func (b *Builder) AutoAction(mode, depMode BuildMode, p *load.Package) *Action
AutoAction returns the "right" action for go build or go install of p.
func (b *Builder) CFlags(p *load.Package) (cppflags, cflags, cxxflags, fflags, ldflags []string, err error)
CFlags returns the flags to use when invoking the C, C++ or Fortran compilers, or cgo.
func (b *Builder) CompileAction(mode, depMode BuildMode, p *load.Package) *Action
CompileAction returns the action for compiling and possibly installing (according to mode) the given package. The resulting action is only for building packages (archives), never for linking executables. depMode is the action (build or install) to use when building dependencies. To turn package main into an executable, call b.Link instead.
func (b *Builder) Do(root *Action)
do runs the action graph rooted at root.
func (b *Builder) GccCmd(incdir, workdir string) []string
gccCmd returns a gcc command line prefix defaultCC is defined in zdefaultcc.go, written by cmd/dist.
func (b *Builder) GxxCmd(incdir, workdir string) []string
gxxCmd returns a g++ command line prefix defaultCXX is defined in zdefaultcc.go, written by cmd/dist.
func (b *Builder) Init()
func (b *Builder) LinkAction(mode, depMode BuildMode, p *load.Package) *Action
LinkAction returns the action for linking p into an executable and possibly installing the result (according to mode). depMode is the action (build or install) to use when compiling dependencies.
func (b *Builder) Mkdir(dir string) error
mkdir makes the named directory.
func (b *Builder) NewObjdir() string
NewObjdir returns the name of a fresh object directory under b.WorkDir. It is up to the caller to call b.Mkdir on the result at an appropriate time. The result ends in a slash, so that file names in that directory can be constructed with direct string addition.
NewObjdir must be called only from a single goroutine at a time, so it is safe to call during action graph construction, but it must not be called during action graph execution.
func (b *Builder) PkgconfigCmd() string
PkgconfigCmd returns a pkg-config binary name defaultPkgConfig is defined in zdefaultcc.go, written by cmd/dist.
func (b *Builder) Showcmd(dir string, format string, args ...interface{})
showcmd prints the given command to standard output for the implementation of -n or -x.
func (b *Builder) Symlink(oldname, newname string) error
symlink creates a symlink newname -> oldname.
func (b *Builder) VetAction(mode, depMode BuildMode, p *load.Package) *Action
VetAction returns the action for running go vet on package p. It depends on the action for compiling p. If the caller may be causing p to be installed, it is up to the caller to make sure that the install depends on (runs after) vet.