Black Lives Matter. Support the Equal Justice Initiative.

Package work

import "cmd/go/internal/work"
Overview
Index

Overview ▾

Index ▾

Constants
Variables
func AddBuildFlags(cmd *base.Command, mask BuildFlagMask)
func BuildInit()
func BuildInstallFunc(b *Builder, ctx context.Context, a *Action) (err error)
func CheckGOOSARCHPair(goos, goarch string) error
func FindExecCmd() []string
func InstallPackages(ctx context.Context, patterns []string, pkgs []*load.Package)
type Action
    func (a *Action) BuildActionID() string
    func (a *Action) BuildContentID() string
    func (a *Action) BuildID() string
    func (a *Action) BuiltTarget() string
type BuildFlagMask
type BuildMode
type Builder
    func (b *Builder) AutoAction(mode, depMode BuildMode, p *load.Package) *Action
    func (b *Builder) CFlags(p *load.Package) (cppflags, cflags, cxxflags, fflags, ldflags []string, err error)
    func (b *Builder) CompileAction(mode, depMode BuildMode, p *load.Package) *Action
    func (b *Builder) Do(ctx context.Context, root *Action)
    func (b *Builder) GccCmd(incdir, workdir string) []string
    func (b *Builder) GxxCmd(incdir, workdir string) []string
    func (b *Builder) Init()
    func (b *Builder) LinkAction(mode, depMode BuildMode, p *load.Package) *Action
    func (b *Builder) Mkdir(dir string) error
    func (b *Builder) NewObjdir() string
    func (b *Builder) PkgconfigCmd() string
    func (b *Builder) Showcmd(dir string, format string, args ...interface{})
    func (b *Builder) Symlink(oldname, newname string) error
    func (b *Builder) VetAction(mode, depMode BuildMode, p *load.Package) *Action

Package files

action.go build.go buildid.go exec.go gc.go gccgo.go init.go security.go

Constants

Windows has a limit of 32 KB arguments. To be conservative and not worry about whether that includes spaces or not, just use 30 KB. Darwin's limit is less clear. The OS claims 256KB, but we've seen failures with arglen as small as 50KB.

const ArgLengthForResponseFile = (30 << 10)

Variables

var BuildToolchain toolchain = noToolchain{}
var CmdBuild = &base.Command{
    UsageLine: "go 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 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 an existing directory or
ends with a slash or backslash, then any resulting executables
will be written to that directory.

The -i flag installs the packages that are dependencies of the target.
The -i flag is deprecated. Compiled packages are cached automatically.

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, windows/amd64,
        linux/ppc64le and linux/arm64 (only for 48-bit VMA).
    -msan
        enable interoperation with memory sanitizer.
        Supported only on linux/amd64, linux/arm64
        and only with Clang/LLVM as the host C compiler.
        On linux/arm64, pie build mode will be used.
    -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
        build code that will be linked against shared libraries previously
        created with -buildmode=shared.
    -mod mode
        module download mode to use: readonly, vendor, or mod.
        By default, if a vendor directory is present and the go version in go.mod
        is 1.14 or higher, the go command acts as if -mod=vendor were set.
        Otherwise, the go command acts as if -mod=readonly were set.
        See https://golang.org/ref/mod#build-commands for details.
    -modcacherw
        leave newly-created directories in the module cache read-write
        instead of making them read-only.
    -modfile file
        in module aware mode, read (and possibly write) an alternate go.mod
        file instead of the one in the module root directory. A file named
        "go.mod" must still be present in order to determine the module root
        directory, but it is not accessed. When -modfile is specified, an
        alternate go.sum file is also used: its path is derived from the
        -modfile flag by trimming the ".mod" extension and appending ".sum".
    -overlay file
        read a JSON config file that provides an overlay for build operations.
        The file is a JSON struct with a single field, named 'Replace', that
        maps each disk file path (a string) to its backing file path, so that
        a build will run as if the disk file path exists with the contents
        given by the backing file paths, or as if the disk file path does not
        exist if its backing file path is empty. Support for the -overlay flag
        has some limitations:importantly, cgo files included from outside the
        include path must be  in the same directory as the Go package they are
        included from, and overlays will not appear when binaries and tests are
        run through go run and go test respectively.
    -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 [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.

If the arguments have version suffixes (like @latest or @v1.0.0), "go install"
builds packages in module-aware mode, ignoring the go.mod file in the current
directory or any parent directory, if there is one. This is useful for
installing executables without affecting the dependencies of the main module.
To eliminate ambiguity about which module versions are used in the build, the
arguments must satisfy the following constraints:

- Arguments must be package paths or package patterns (with "..." wildcards).
  They must not be standard packages (like fmt), meta-patterns (std, cmd,
  all), or relative or absolute file paths.
- All arguments must have the same version suffix. Different queries are not
  allowed, even if they refer to the same version.
- All arguments must refer to packages in the same module at the same version.
- No module is considered the "main" module. If the module containing
  packages named on the command line has a go.mod file, it must not contain
  directives (replace and exclude) that would cause it to be interpreted
  differently than if it were the main module. The module must not require
  a higher version of itself.
- Package path arguments must refer to main packages. Pattern arguments
  will only match main packages.

If the arguments don't have version suffixes, "go install" may run in
module-aware mode or GOPATH mode, depending on the GO111MODULE environment
variable and the presence of a go.mod file. See 'go help modules' for details.
If module-aware mode is enabled, "go install" runs in the context of the main
module.

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.
The -i flag is deprecated. Compiled packages are cached automatically.

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.
    `,
}

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 ExecCmd []string
var GccgoName, GccgoBin string

VetExplicit records whether the vet flags were set explicitly on the command line.

var VetExplicit bool

VetFlags are the default flags to pass to vet. The caller is expected to set them before executing any vet actions.

var VetFlags []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.

var VetTool string

func AddBuildFlags

func AddBuildFlags(cmd *base.Command, mask BuildFlagMask)

AddBuildFlags adds the flags common to the build, clean, get, install, list, run, and test commands.

func BuildInit

func BuildInit()

func BuildInstallFunc

func BuildInstallFunc(b *Builder, ctx context.Context, a *Action) (err error)

BuildInstallFunc is the action for installing a single package or executable.

func CheckGOOSARCHPair

func CheckGOOSARCHPair(goos, goarch string) error

func FindExecCmd

func FindExecCmd() []string

FindExecCmd derives the value of ExecCmd to use. It returns that value and leaves ExecCmd set for direct use.

func InstallPackages

func InstallPackages(ctx context.Context, patterns []string, pkgs []*load.Package)

type Action

An Action represents a single action in the action graph.

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, context.Context, *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
}

func (*Action) BuildActionID

func (a *Action) BuildActionID() string

BuildActionID returns the action ID section of a's build ID.

func (*Action) BuildContentID

func (a *Action) BuildContentID() string

BuildContentID returns the content ID section of a's build ID.

func (*Action) BuildID

func (a *Action) BuildID() string

BuildID returns a's build ID.

func (*Action) BuiltTarget

func (a *Action) BuiltTarget() string

BuiltTarget returns the actual file that was built. This differs from Target when the result was cached.

type BuildFlagMask

type BuildFlagMask int
const (
    DefaultBuildFlags BuildFlagMask = 0
    OmitModFlag       BuildFlagMask = 1 << iota
    OmitModCommonFlags
    OmitVFlag
)

type BuildMode

BuildMode specifies the build mode: are we just building things or also installing the results?

type BuildMode int
const (
    ModeBuild BuildMode = iota
    ModeInstall
    ModeBuggyInstall

    ModeVetOnly = 1 << 8
)

type Builder

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.

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
}

func (*Builder) AutoAction

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 (*Builder) CFlags

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 (*Builder) CompileAction

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 (*Builder) Do

func (b *Builder) Do(ctx context.Context, root *Action)

do runs the action graph rooted at root.

func (*Builder) GccCmd

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 (*Builder) GxxCmd

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 (*Builder) Init

func (b *Builder) Init()

func (*Builder) LinkAction

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 (*Builder) Mkdir

func (b *Builder) Mkdir(dir string) error

mkdir makes the named directory.

func (*Builder) NewObjdir

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 (*Builder) PkgconfigCmd

func (b *Builder) PkgconfigCmd() string

PkgconfigCmd returns a pkg-config binary name defaultPkgConfig is defined in zdefaultcc.go, written by cmd/dist.

func (*Builder) Showcmd

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 (*Builder) VetAction

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.