Black Lives Matter. Support the Equal Justice Initiative.

Source file src/cmd/go/internal/work/buildid.go

Documentation: cmd/go/internal/work

     1  // Copyright 2017 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package work
     6  
     7  import (
     8  	"bytes"
     9  	"fmt"
    10  	exec "internal/execabs"
    11  	"os"
    12  	"strings"
    13  
    14  	"cmd/go/internal/base"
    15  	"cmd/go/internal/cache"
    16  	"cmd/go/internal/cfg"
    17  	"cmd/go/internal/fsys"
    18  	"cmd/go/internal/str"
    19  	"cmd/internal/buildid"
    20  )
    21  
    22  // Build IDs
    23  //
    24  // Go packages and binaries are stamped with build IDs that record both
    25  // the action ID, which is a hash of the inputs to the action that produced
    26  // the packages or binary, and the content ID, which is a hash of the action
    27  // output, namely the archive or binary itself. The hash is the same one
    28  // used by the build artifact cache (see cmd/go/internal/cache), but
    29  // truncated when stored in packages and binaries, as the full length is not
    30  // needed and is a bit unwieldy. The precise form is
    31  //
    32  //	actionID/[.../]contentID
    33  //
    34  // where the actionID and contentID are prepared by buildid.HashToString below.
    35  // and are found by looking for the first or last slash.
    36  // Usually the buildID is simply actionID/contentID, but see below for an
    37  // exception.
    38  //
    39  // The build ID serves two primary purposes.
    40  //
    41  // 1. The action ID half allows installed packages and binaries to serve as
    42  // one-element cache entries. If we intend to build math.a with a given
    43  // set of inputs summarized in the action ID, and the installed math.a already
    44  // has that action ID, we can reuse the installed math.a instead of rebuilding it.
    45  //
    46  // 2. The content ID half allows the easy preparation of action IDs for steps
    47  // that consume a particular package or binary. The content hash of every
    48  // input file for a given action must be included in the action ID hash.
    49  // Storing the content ID in the build ID lets us read it from the file with
    50  // minimal I/O, instead of reading and hashing the entire file.
    51  // This is especially effective since packages and binaries are typically
    52  // the largest inputs to an action.
    53  //
    54  // Separating action ID from content ID is important for reproducible builds.
    55  // The compiler is compiled with itself. If an output were represented by its
    56  // own action ID (instead of content ID) when computing the action ID of
    57  // the next step in the build process, then the compiler could never have its
    58  // own input action ID as its output action ID (short of a miraculous hash collision).
    59  // Instead we use the content IDs to compute the next action ID, and because
    60  // the content IDs converge, so too do the action IDs and therefore the
    61  // build IDs and the overall compiler binary. See cmd/dist's cmdbootstrap
    62  // for the actual convergence sequence.
    63  //
    64  // The “one-element cache” purpose is a bit more complex for installed
    65  // binaries. For a binary, like cmd/gofmt, there are two steps: compile
    66  // cmd/gofmt/*.go into main.a, and then link main.a into the gofmt binary.
    67  // We do not install gofmt's main.a, only the gofmt binary. Being able to
    68  // decide that the gofmt binary is up-to-date means computing the action ID
    69  // for the final link of the gofmt binary and comparing it against the
    70  // already-installed gofmt binary. But computing the action ID for the link
    71  // means knowing the content ID of main.a, which we did not keep.
    72  // To sidestep this problem, each binary actually stores an expanded build ID:
    73  //
    74  //	actionID(binary)/actionID(main.a)/contentID(main.a)/contentID(binary)
    75  //
    76  // (Note that this can be viewed equivalently as:
    77  //
    78  //	actionID(binary)/buildID(main.a)/contentID(binary)
    79  //
    80  // Storing the buildID(main.a) in the middle lets the computations that care
    81  // about the prefix or suffix halves ignore the middle and preserves the
    82  // original build ID as a contiguous string.)
    83  //
    84  // During the build, when it's time to build main.a, the gofmt binary has the
    85  // information needed to decide whether the eventual link would produce
    86  // the same binary: if the action ID for main.a's inputs matches and then
    87  // the action ID for the link step matches when assuming the given main.a
    88  // content ID, then the binary as a whole is up-to-date and need not be rebuilt.
    89  //
    90  // This is all a bit complex and may be simplified once we can rely on the
    91  // main cache, but at least at the start we will be using the content-based
    92  // staleness determination without a cache beyond the usual installed
    93  // package and binary locations.
    94  
    95  const buildIDSeparator = "/"
    96  
    97  // actionID returns the action ID half of a build ID.
    98  func actionID(buildID string) string {
    99  	i := strings.Index(buildID, buildIDSeparator)
   100  	if i < 0 {
   101  		return buildID
   102  	}
   103  	return buildID[:i]
   104  }
   105  
   106  // contentID returns the content ID half of a build ID.
   107  func contentID(buildID string) string {
   108  	return buildID[strings.LastIndex(buildID, buildIDSeparator)+1:]
   109  }
   110  
   111  // toolID returns the unique ID to use for the current copy of the
   112  // named tool (asm, compile, cover, link).
   113  //
   114  // It is important that if the tool changes (for example a compiler bug is fixed
   115  // and the compiler reinstalled), toolID returns a different string, so that old
   116  // package archives look stale and are rebuilt (with the fixed compiler).
   117  // This suggests using a content hash of the tool binary, as stored in the build ID.
   118  //
   119  // Unfortunately, we can't just open the tool binary, because the tool might be
   120  // invoked via a wrapper program specified by -toolexec and we don't know
   121  // what the wrapper program does. In particular, we want "-toolexec toolstash"
   122  // to continue working: it does no good if "-toolexec toolstash" is executing a
   123  // stashed copy of the compiler but the go command is acting as if it will run
   124  // the standard copy of the compiler. The solution is to ask the tool binary to tell
   125  // us its own build ID using the "-V=full" flag now supported by all tools.
   126  // Then we know we're getting the build ID of the compiler that will actually run
   127  // during the build. (How does the compiler binary know its own content hash?
   128  // We store it there using updateBuildID after the standard link step.)
   129  //
   130  // A final twist is that we'd prefer to have reproducible builds for release toolchains.
   131  // It should be possible to cross-compile for Windows from either Linux or Mac
   132  // or Windows itself and produce the same binaries, bit for bit. If the tool ID,
   133  // which influences the action ID half of the build ID, is based on the content ID,
   134  // then the Linux compiler binary and Mac compiler binary will have different tool IDs
   135  // and therefore produce executables with different action IDs.
   136  // To avoid this problem, for releases we use the release version string instead
   137  // of the compiler binary's content hash. This assumes that all compilers built
   138  // on all different systems are semantically equivalent, which is of course only true
   139  // modulo bugs. (Producing the exact same executables also requires that the different
   140  // build setups agree on details like $GOROOT and file name paths, but at least the
   141  // tool IDs do not make it impossible.)
   142  func (b *Builder) toolID(name string) string {
   143  	b.id.Lock()
   144  	id := b.toolIDCache[name]
   145  	b.id.Unlock()
   146  
   147  	if id != "" {
   148  		return id
   149  	}
   150  
   151  	path := base.Tool(name)
   152  	desc := "go tool " + name
   153  
   154  	// Special case: undocumented -vettool overrides usual vet,
   155  	// for testing vet or supplying an alternative analysis tool.
   156  	if name == "vet" && VetTool != "" {
   157  		path = VetTool
   158  		desc = VetTool
   159  	}
   160  
   161  	cmdline := str.StringList(cfg.BuildToolexec, path, "-V=full")
   162  	cmd := exec.Command(cmdline[0], cmdline[1:]...)
   163  	cmd.Env = base.AppendPWD(os.Environ(), cmd.Dir)
   164  	var stdout, stderr bytes.Buffer
   165  	cmd.Stdout = &stdout
   166  	cmd.Stderr = &stderr
   167  	if err := cmd.Run(); err != nil {
   168  		base.Fatalf("%s: %v\n%s%s", desc, err, stdout.Bytes(), stderr.Bytes())
   169  	}
   170  
   171  	line := stdout.String()
   172  	f := strings.Fields(line)
   173  	if len(f) < 3 || f[0] != name && path != VetTool || f[1] != "version" || f[2] == "devel" && !strings.HasPrefix(f[len(f)-1], "buildID=") {
   174  		base.Fatalf("%s -V=full: unexpected output:\n\t%s", desc, line)
   175  	}
   176  	if f[2] == "devel" {
   177  		// On the development branch, use the content ID part of the build ID.
   178  		id = contentID(f[len(f)-1])
   179  	} else {
   180  		// For a release, the output is like: "compile version go1.9.1 X:framepointer".
   181  		// Use the whole line.
   182  		id = strings.TrimSpace(line)
   183  	}
   184  
   185  	b.id.Lock()
   186  	b.toolIDCache[name] = id
   187  	b.id.Unlock()
   188  
   189  	return id
   190  }
   191  
   192  // gccToolID returns the unique ID to use for a tool that is invoked
   193  // by the GCC driver. This is used particularly for gccgo, but this can also
   194  // be used for gcc, g++, gfortran, etc.; those tools all use the GCC
   195  // driver under different names. The approach used here should also
   196  // work for sufficiently new versions of clang. Unlike toolID, the
   197  // name argument is the program to run. The language argument is the
   198  // type of input file as passed to the GCC driver's -x option.
   199  //
   200  // For these tools we have no -V=full option to dump the build ID,
   201  // but we can run the tool with -v -### to reliably get the compiler proper
   202  // and hash that. That will work in the presence of -toolexec.
   203  //
   204  // In order to get reproducible builds for released compilers, we
   205  // detect a released compiler by the absence of "experimental" in the
   206  // --version output, and in that case we just use the version string.
   207  func (b *Builder) gccgoToolID(name, language string) (string, error) {
   208  	key := name + "." + language
   209  	b.id.Lock()
   210  	id := b.toolIDCache[key]
   211  	b.id.Unlock()
   212  
   213  	if id != "" {
   214  		return id, nil
   215  	}
   216  
   217  	// Invoke the driver with -### to see the subcommands and the
   218  	// version strings. Use -x to set the language. Pretend to
   219  	// compile an empty file on standard input.
   220  	cmdline := str.StringList(cfg.BuildToolexec, name, "-###", "-x", language, "-c", "-")
   221  	cmd := exec.Command(cmdline[0], cmdline[1:]...)
   222  	cmd.Env = base.AppendPWD(os.Environ(), cmd.Dir)
   223  	// Force untranslated output so that we see the string "version".
   224  	cmd.Env = append(cmd.Env, "LC_ALL=C")
   225  	out, err := cmd.CombinedOutput()
   226  	if err != nil {
   227  		return "", fmt.Errorf("%s: %v; output: %q", name, err, out)
   228  	}
   229  
   230  	version := ""
   231  	lines := strings.Split(string(out), "\n")
   232  	for _, line := range lines {
   233  		if fields := strings.Fields(line); len(fields) > 1 && fields[1] == "version" {
   234  			version = line
   235  			break
   236  		}
   237  	}
   238  	if version == "" {
   239  		return "", fmt.Errorf("%s: can not find version number in %q", name, out)
   240  	}
   241  
   242  	if !strings.Contains(version, "experimental") {
   243  		// This is a release. Use this line as the tool ID.
   244  		id = version
   245  	} else {
   246  		// This is a development version. The first line with
   247  		// a leading space is the compiler proper.
   248  		compiler := ""
   249  		for _, line := range lines {
   250  			if len(line) > 1 && line[0] == ' ' {
   251  				compiler = line
   252  				break
   253  			}
   254  		}
   255  		if compiler == "" {
   256  			return "", fmt.Errorf("%s: can not find compilation command in %q", name, out)
   257  		}
   258  
   259  		fields := strings.Fields(compiler)
   260  		if len(fields) == 0 {
   261  			return "", fmt.Errorf("%s: compilation command confusion %q", name, out)
   262  		}
   263  		exe := fields[0]
   264  		if !strings.ContainsAny(exe, `/\`) {
   265  			if lp, err := exec.LookPath(exe); err == nil {
   266  				exe = lp
   267  			}
   268  		}
   269  		id, err = buildid.ReadFile(exe)
   270  		if err != nil {
   271  			return "", err
   272  		}
   273  
   274  		// If we can't find a build ID, use a hash.
   275  		if id == "" {
   276  			id = b.fileHash(exe)
   277  		}
   278  	}
   279  
   280  	b.id.Lock()
   281  	b.toolIDCache[key] = id
   282  	b.id.Unlock()
   283  
   284  	return id, nil
   285  }
   286  
   287  // Check if assembler used by gccgo is GNU as.
   288  func assemblerIsGas() bool {
   289  	cmd := exec.Command(BuildToolchain.compiler(), "-print-prog-name=as")
   290  	assembler, err := cmd.Output()
   291  	if err == nil {
   292  		cmd := exec.Command(strings.TrimSpace(string(assembler)), "--version")
   293  		out, err := cmd.Output()
   294  		return err == nil && strings.Contains(string(out), "GNU")
   295  	} else {
   296  		return false
   297  	}
   298  }
   299  
   300  // gccgoBuildIDFile creates an assembler file that records the
   301  // action's build ID in an SHF_EXCLUDE section for ELF files or
   302  // in a CSECT in XCOFF files.
   303  func (b *Builder) gccgoBuildIDFile(a *Action) (string, error) {
   304  	sfile := a.Objdir + "_buildid.s"
   305  
   306  	var buf bytes.Buffer
   307  	if cfg.Goos == "aix" {
   308  		fmt.Fprintf(&buf, "\t.csect .go.buildid[XO]\n")
   309  	} else if (cfg.Goos != "solaris" && cfg.Goos != "illumos") || assemblerIsGas() {
   310  		fmt.Fprintf(&buf, "\t"+`.section .go.buildid,"e"`+"\n")
   311  	} else if cfg.Goarch == "sparc" || cfg.Goarch == "sparc64" {
   312  		fmt.Fprintf(&buf, "\t"+`.section ".go.buildid",#exclude`+"\n")
   313  	} else { // cfg.Goarch == "386" || cfg.Goarch == "amd64"
   314  		fmt.Fprintf(&buf, "\t"+`.section .go.buildid,#exclude`+"\n")
   315  	}
   316  	fmt.Fprintf(&buf, "\t.byte ")
   317  	for i := 0; i < len(a.buildID); i++ {
   318  		if i > 0 {
   319  			if i%8 == 0 {
   320  				fmt.Fprintf(&buf, "\n\t.byte ")
   321  			} else {
   322  				fmt.Fprintf(&buf, ",")
   323  			}
   324  		}
   325  		fmt.Fprintf(&buf, "%#02x", a.buildID[i])
   326  	}
   327  	fmt.Fprintf(&buf, "\n")
   328  	if cfg.Goos != "solaris" && cfg.Goos != "illumos" && cfg.Goos != "aix" {
   329  		secType := "@progbits"
   330  		if cfg.Goarch == "arm" {
   331  			secType = "%progbits"
   332  		}
   333  		fmt.Fprintf(&buf, "\t"+`.section .note.GNU-stack,"",%s`+"\n", secType)
   334  		fmt.Fprintf(&buf, "\t"+`.section .note.GNU-split-stack,"",%s`+"\n", secType)
   335  	}
   336  
   337  	if cfg.BuildN || cfg.BuildX {
   338  		for _, line := range bytes.Split(buf.Bytes(), []byte("\n")) {
   339  			b.Showcmd("", "echo '%s' >> %s", line, sfile)
   340  		}
   341  		if cfg.BuildN {
   342  			return sfile, nil
   343  		}
   344  	}
   345  
   346  	if err := os.WriteFile(sfile, buf.Bytes(), 0666); err != nil {
   347  		return "", err
   348  	}
   349  
   350  	return sfile, nil
   351  }
   352  
   353  // buildID returns the build ID found in the given file.
   354  // If no build ID is found, buildID returns the content hash of the file.
   355  func (b *Builder) buildID(file string) string {
   356  	b.id.Lock()
   357  	id := b.buildIDCache[file]
   358  	b.id.Unlock()
   359  
   360  	if id != "" {
   361  		return id
   362  	}
   363  
   364  	id, err := buildid.ReadFile(file)
   365  	if err != nil {
   366  		id = b.fileHash(file)
   367  	}
   368  
   369  	b.id.Lock()
   370  	b.buildIDCache[file] = id
   371  	b.id.Unlock()
   372  
   373  	return id
   374  }
   375  
   376  // fileHash returns the content hash of the named file.
   377  func (b *Builder) fileHash(file string) string {
   378  	file, _ = fsys.OverlayPath(file)
   379  	sum, err := cache.FileHash(file)
   380  	if err != nil {
   381  		return ""
   382  	}
   383  	return buildid.HashToString(sum)
   384  }
   385  
   386  // useCache tries to satisfy the action a, which has action ID actionHash,
   387  // by using a cached result from an earlier build. At the moment, the only
   388  // cached result is the installed package or binary at target.
   389  // If useCache decides that the cache can be used, it sets a.buildID
   390  // and a.built for use by parent actions and then returns true.
   391  // Otherwise it sets a.buildID to a temporary build ID for use in the build
   392  // and returns false. When useCache returns false the expectation is that
   393  // the caller will build the target and then call updateBuildID to finish the
   394  // build ID computation.
   395  // When useCache returns false, it may have initiated buffering of output
   396  // during a's work. The caller should defer b.flushOutput(a), to make sure
   397  // that flushOutput is eventually called regardless of whether the action
   398  // succeeds. The flushOutput call must happen after updateBuildID.
   399  func (b *Builder) useCache(a *Action, actionHash cache.ActionID, target string) bool {
   400  	// The second half of the build ID here is a placeholder for the content hash.
   401  	// It's important that the overall buildID be unlikely verging on impossible
   402  	// to appear in the output by chance, but that should be taken care of by
   403  	// the actionID half; if it also appeared in the input that would be like an
   404  	// engineered 120-bit partial SHA256 collision.
   405  	a.actionID = actionHash
   406  	actionID := buildid.HashToString(actionHash)
   407  	if a.json != nil {
   408  		a.json.ActionID = actionID
   409  	}
   410  	contentID := actionID // temporary placeholder, likely unique
   411  	a.buildID = actionID + buildIDSeparator + contentID
   412  
   413  	// Executable binaries also record the main build ID in the middle.
   414  	// See "Build IDs" comment above.
   415  	if a.Mode == "link" {
   416  		mainpkg := a.Deps[0]
   417  		a.buildID = actionID + buildIDSeparator + mainpkg.buildID + buildIDSeparator + contentID
   418  	}
   419  
   420  	// Check to see if target exists and matches the expected action ID.
   421  	// If so, it's up to date and we can reuse it instead of rebuilding it.
   422  	var buildID string
   423  	if target != "" && !cfg.BuildA {
   424  		buildID, _ = buildid.ReadFile(target)
   425  		if strings.HasPrefix(buildID, actionID+buildIDSeparator) {
   426  			a.buildID = buildID
   427  			if a.json != nil {
   428  				a.json.BuildID = a.buildID
   429  			}
   430  			a.built = target
   431  			// Poison a.Target to catch uses later in the build.
   432  			a.Target = "DO NOT USE - " + a.Mode
   433  			return true
   434  		}
   435  	}
   436  
   437  	// Special case for building a main package: if the only thing we
   438  	// want the package for is to link a binary, and the binary is
   439  	// already up-to-date, then to avoid a rebuild, report the package
   440  	// as up-to-date as well. See "Build IDs" comment above.
   441  	// TODO(rsc): Rewrite this code to use a TryCache func on the link action.
   442  	if target != "" && !cfg.BuildA && !b.NeedExport && a.Mode == "build" && len(a.triggers) == 1 && a.triggers[0].Mode == "link" {
   443  		buildID, err := buildid.ReadFile(target)
   444  		if err == nil {
   445  			id := strings.Split(buildID, buildIDSeparator)
   446  			if len(id) == 4 && id[1] == actionID {
   447  				// Temporarily assume a.buildID is the package build ID
   448  				// stored in the installed binary, and see if that makes
   449  				// the upcoming link action ID a match. If so, report that
   450  				// we built the package, safe in the knowledge that the
   451  				// link step will not ask us for the actual package file.
   452  				// Note that (*Builder).LinkAction arranged that all of
   453  				// a.triggers[0]'s dependencies other than a are also
   454  				// dependencies of a, so that we can be sure that,
   455  				// other than a.buildID, b.linkActionID is only accessing
   456  				// build IDs of completed actions.
   457  				oldBuildID := a.buildID
   458  				a.buildID = id[1] + buildIDSeparator + id[2]
   459  				linkID := buildid.HashToString(b.linkActionID(a.triggers[0]))
   460  				if id[0] == linkID {
   461  					// Best effort attempt to display output from the compile and link steps.
   462  					// If it doesn't work, it doesn't work: reusing the cached binary is more
   463  					// important than reprinting diagnostic information.
   464  					if c := cache.Default(); c != nil {
   465  						showStdout(b, c, a.actionID, "stdout")      // compile output
   466  						showStdout(b, c, a.actionID, "link-stdout") // link output
   467  					}
   468  
   469  					// Poison a.Target to catch uses later in the build.
   470  					a.Target = "DO NOT USE - main build pseudo-cache Target"
   471  					a.built = "DO NOT USE - main build pseudo-cache built"
   472  					if a.json != nil {
   473  						a.json.BuildID = a.buildID
   474  					}
   475  					return true
   476  				}
   477  				// Otherwise restore old build ID for main build.
   478  				a.buildID = oldBuildID
   479  			}
   480  		}
   481  	}
   482  
   483  	// Special case for linking a test binary: if the only thing we
   484  	// want the binary for is to run the test, and the test result is cached,
   485  	// then to avoid the link step, report the link as up-to-date.
   486  	// We avoid the nested build ID problem in the previous special case
   487  	// by recording the test results in the cache under the action ID half.
   488  	if !cfg.BuildA && len(a.triggers) == 1 && a.triggers[0].TryCache != nil && a.triggers[0].TryCache(b, a.triggers[0]) {
   489  		// Best effort attempt to display output from the compile and link steps.
   490  		// If it doesn't work, it doesn't work: reusing the test result is more
   491  		// important than reprinting diagnostic information.
   492  		if c := cache.Default(); c != nil {
   493  			showStdout(b, c, a.Deps[0].actionID, "stdout")      // compile output
   494  			showStdout(b, c, a.Deps[0].actionID, "link-stdout") // link output
   495  		}
   496  
   497  		// Poison a.Target to catch uses later in the build.
   498  		a.Target = "DO NOT USE -  pseudo-cache Target"
   499  		a.built = "DO NOT USE - pseudo-cache built"
   500  		return true
   501  	}
   502  
   503  	if b.IsCmdList {
   504  		// Invoked during go list to compute and record staleness.
   505  		if p := a.Package; p != nil && !p.Stale {
   506  			p.Stale = true
   507  			if cfg.BuildA {
   508  				p.StaleReason = "build -a flag in use"
   509  			} else {
   510  				p.StaleReason = "build ID mismatch"
   511  				for _, p1 := range p.Internal.Imports {
   512  					if p1.Stale && p1.StaleReason != "" {
   513  						if strings.HasPrefix(p1.StaleReason, "stale dependency: ") {
   514  							p.StaleReason = p1.StaleReason
   515  							break
   516  						}
   517  						if strings.HasPrefix(p.StaleReason, "build ID mismatch") {
   518  							p.StaleReason = "stale dependency: " + p1.ImportPath
   519  						}
   520  					}
   521  				}
   522  			}
   523  		}
   524  
   525  		// Fall through to update a.buildID from the build artifact cache,
   526  		// which will affect the computation of buildIDs for targets
   527  		// higher up in the dependency graph.
   528  	}
   529  
   530  	// Check the build artifact cache.
   531  	// We treat hits in this cache as being "stale" for the purposes of go list
   532  	// (in effect, "stale" means whether p.Target is up-to-date),
   533  	// but we're still happy to use results from the build artifact cache.
   534  	if c := cache.Default(); c != nil {
   535  		if !cfg.BuildA {
   536  			if file, _, err := c.GetFile(actionHash); err == nil {
   537  				if buildID, err := buildid.ReadFile(file); err == nil {
   538  					if err := showStdout(b, c, a.actionID, "stdout"); err == nil {
   539  						a.built = file
   540  						a.Target = "DO NOT USE - using cache"
   541  						a.buildID = buildID
   542  						if a.json != nil {
   543  							a.json.BuildID = a.buildID
   544  						}
   545  						if p := a.Package; p != nil {
   546  							// Clearer than explaining that something else is stale.
   547  							p.StaleReason = "not installed but available in build cache"
   548  						}
   549  						return true
   550  					}
   551  				}
   552  			}
   553  		}
   554  
   555  		// Begin saving output for later writing to cache.
   556  		a.output = []byte{}
   557  	}
   558  
   559  	return false
   560  }
   561  
   562  func showStdout(b *Builder, c *cache.Cache, actionID cache.ActionID, key string) error {
   563  	stdout, stdoutEntry, err := c.GetBytes(cache.Subkey(actionID, key))
   564  	if err != nil {
   565  		return err
   566  	}
   567  
   568  	if len(stdout) > 0 {
   569  		if cfg.BuildX || cfg.BuildN {
   570  			b.Showcmd("", "%s  # internal", joinUnambiguously(str.StringList("cat", c.OutputFile(stdoutEntry.OutputID))))
   571  		}
   572  		if !cfg.BuildN {
   573  			b.Print(string(stdout))
   574  		}
   575  	}
   576  	return nil
   577  }
   578  
   579  // flushOutput flushes the output being queued in a.
   580  func (b *Builder) flushOutput(a *Action) {
   581  	b.Print(string(a.output))
   582  	a.output = nil
   583  }
   584  
   585  // updateBuildID updates the build ID in the target written by action a.
   586  // It requires that useCache was called for action a and returned false,
   587  // and that the build was then carried out and given the temporary
   588  // a.buildID to record as the build ID in the resulting package or binary.
   589  // updateBuildID computes the final content ID and updates the build IDs
   590  // in the binary.
   591  //
   592  // Keep in sync with src/cmd/buildid/buildid.go
   593  func (b *Builder) updateBuildID(a *Action, target string, rewrite bool) error {
   594  	if cfg.BuildX || cfg.BuildN {
   595  		if rewrite {
   596  			b.Showcmd("", "%s # internal", joinUnambiguously(str.StringList(base.Tool("buildid"), "-w", target)))
   597  		}
   598  		if cfg.BuildN {
   599  			return nil
   600  		}
   601  	}
   602  
   603  	// Cache output from compile/link, even if we don't do the rest.
   604  	if c := cache.Default(); c != nil {
   605  		switch a.Mode {
   606  		case "build":
   607  			c.PutBytes(cache.Subkey(a.actionID, "stdout"), a.output)
   608  		case "link":
   609  			// Even though we don't cache the binary, cache the linker text output.
   610  			// We might notice that an installed binary is up-to-date but still
   611  			// want to pretend to have run the linker.
   612  			// Store it under the main package's action ID
   613  			// to make it easier to find when that's all we have.
   614  			for _, a1 := range a.Deps {
   615  				if p1 := a1.Package; p1 != nil && p1.Name == "main" {
   616  					c.PutBytes(cache.Subkey(a1.actionID, "link-stdout"), a.output)
   617  					break
   618  				}
   619  			}
   620  		}
   621  	}
   622  
   623  	// Find occurrences of old ID and compute new content-based ID.
   624  	r, err := os.Open(target)
   625  	if err != nil {
   626  		return err
   627  	}
   628  	matches, hash, err := buildid.FindAndHash(r, a.buildID, 0)
   629  	r.Close()
   630  	if err != nil {
   631  		return err
   632  	}
   633  	newID := a.buildID[:strings.LastIndex(a.buildID, buildIDSeparator)] + buildIDSeparator + buildid.HashToString(hash)
   634  	if len(newID) != len(a.buildID) {
   635  		return fmt.Errorf("internal error: build ID length mismatch %q vs %q", a.buildID, newID)
   636  	}
   637  
   638  	// Replace with new content-based ID.
   639  	a.buildID = newID
   640  	if a.json != nil {
   641  		a.json.BuildID = a.buildID
   642  	}
   643  	if len(matches) == 0 {
   644  		// Assume the user specified -buildid= to override what we were going to choose.
   645  		return nil
   646  	}
   647  
   648  	if rewrite {
   649  		w, err := os.OpenFile(target, os.O_RDWR, 0)
   650  		if err != nil {
   651  			return err
   652  		}
   653  		err = buildid.Rewrite(w, matches, newID)
   654  		if err != nil {
   655  			w.Close()
   656  			return err
   657  		}
   658  		if err := w.Close(); err != nil {
   659  			return err
   660  		}
   661  	}
   662  
   663  	// Cache package builds, but not binaries (link steps).
   664  	// The expectation is that binaries are not reused
   665  	// nearly as often as individual packages, and they're
   666  	// much larger, so the cache-footprint-to-utility ratio
   667  	// of binaries is much lower for binaries.
   668  	// Not caching the link step also makes sure that repeated "go run" at least
   669  	// always rerun the linker, so that they don't get too fast.
   670  	// (We don't want people thinking go is a scripting language.)
   671  	// Note also that if we start caching binaries, then we will
   672  	// copy the binaries out of the cache to run them, and then
   673  	// that will mean the go process is itself writing a binary
   674  	// and then executing it, so we will need to defend against
   675  	// ETXTBSY problems as discussed in exec.go and golang.org/issue/22220.
   676  	if c := cache.Default(); c != nil && a.Mode == "build" {
   677  		r, err := os.Open(target)
   678  		if err == nil {
   679  			if a.output == nil {
   680  				panic("internal error: a.output not set")
   681  			}
   682  			outputID, _, err := c.Put(a.actionID, r)
   683  			r.Close()
   684  			if err == nil && cfg.BuildX {
   685  				b.Showcmd("", "%s # internal", joinUnambiguously(str.StringList("cp", target, c.OutputFile(outputID))))
   686  			}
   687  			if b.NeedExport {
   688  				if err != nil {
   689  					return err
   690  				}
   691  				a.Package.Export = c.OutputFile(outputID)
   692  				a.Package.BuildID = a.buildID
   693  			}
   694  		}
   695  	}
   696  
   697  	return nil
   698  }
   699  

View as plain text