Giant blob of minor changes

[dotfiles/.git] / .config / coc / extensions / coc-go-data / tools / pkg / mod / golang.org / x / tools@v0.0.0-20201105173854-bc9fc8d8c4bc / cmd / toolstash / main.go

// Copyright 2015 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.

// Toolstash provides a way to save, run, and restore a known good copy of the Go toolchain
// and to compare the object files generated by two toolchains.
//
// Usage:
//
//      toolstash [-n] [-v] save [tool...]
//      toolstash [-n] [-v] restore [tool...]
//      toolstash [-n] [-v] [-t] go run x.go
//      toolstash [-n] [-v] [-t] [-cmp] compile x.go
//
// The toolstash command manages a ``stashed'' copy of the Go toolchain
// kept in $GOROOT/pkg/toolstash. In this case, the toolchain means the
// tools available with the 'go tool' command as well as the go, godoc, and gofmt
// binaries.
//
// The command ``toolstash save'', typically run when the toolchain is known to be working,
// copies the toolchain from its installed location to the toolstash directory.
// Its inverse, ``toolchain restore'', typically run when the toolchain is known to be broken,
// copies the toolchain from the toolstash directory back to the installed locations.
// If additional arguments are given, the save or restore applies only to the named tools.
// Otherwise, it applies to all tools.
//
// Otherwise, toolstash's arguments should be a command line beginning with the
// name of a toolchain binary, which may be a short name like compile or a complete path
// to an installed binary. Toolstash runs the command line using the stashed
// copy of the binary instead of the installed one.
//
// The -n flag causes toolstash to print the commands that would be executed
// but not execute them. The combination -n -cmp shows the two commands
// that would be compared and then exits successfully. A real -cmp run might
// run additional commands for diagnosis of an output mismatch.
//
// The -v flag causes toolstash to print the commands being executed.
//
// The -t flag causes toolstash to print the time elapsed during while the
// command ran.
//
// Comparing
//
// The -cmp flag causes toolstash to run both the installed and the stashed
// copy of an assembler or compiler and check that they produce identical
// object files. If not, toolstash reports the mismatch and exits with a failure status.
// As part of reporting the mismatch, toolstash reinvokes the command with
// the -S=2 flag and identifies the first divergence in the assembly output.
// If the command is a Go compiler, toolstash also determines whether the
// difference is triggered by optimization passes.
// On failure, toolstash leaves additional information in files named
// similarly to the default output file. If the compilation would normally
// produce a file x.6, the output from the stashed tool is left in x.6.stash
// and the debugging traces are left in x.6.log and x.6.stash.log.
//
// The -cmp flag is a no-op when the command line is not invoking an
// assembler or compiler.
//
// For example, when working on code cleanup that should not affect
// compiler output, toolstash can be used to compare the old and new
// compiler output:
//
//      toolstash save
//      <edit compiler sources>
//      go tool dist install cmd/compile # install compiler only
//      toolstash -cmp compile x.go
//
// Go Command Integration
//
// The go command accepts a -toolexec flag that specifies a program
// to use to run the build tools.
//
// To build with the stashed tools:
//
//      go build -toolexec toolstash x.go
//
// To build with the stashed go command and the stashed tools:
//
//      toolstash go build -toolexec toolstash x.go
//
// To verify that code cleanup in the compilers does not make any
// changes to the objects being generated for the entire tree:
//
//      # Build working tree and save tools.
//      ./make.bash
//      toolstash save
//
//      <edit compiler sources>
//
//      # Install new tools, but do not rebuild the rest of tree,
//      # since the compilers might generate buggy code.
//      go tool dist install cmd/compile
//
//      # Check that new tools behave identically to saved tools.
//      go build -toolexec 'toolstash -cmp' -a std
//
//      # If not, restore, in order to keep working on Go code.
//      toolstash restore
//
// Version Skew
//
// The Go tools write the current Go version to object files, and (outside
// release branches) that version includes the hash and time stamp
// of the most recent Git commit. Functionally equivalent
// compilers built at different Git versions may produce object files that
// differ only in the recorded version. Toolstash ignores version mismatches
// when comparing object files, but the standard tools will refuse to compile
// or link together packages with different object versions.
//
// For the full build in the final example above to work, both the stashed
// and the installed tools must use the same version string.
// One way to ensure this is not to commit any of the changes being
// tested, so that the Git HEAD hash is the same for both builds.
// A more robust way to force the tools to have the same version string
// is to write a $GOROOT/VERSION file, which overrides the Git-based version
// computation:
//
//      echo devel >$GOROOT/VERSION
//
// The version can be arbitrary text, but to pass all.bash's API check, it must
// contain the substring ``devel''. The VERSION file must be created before
// building either version of the toolchain.
//
package main // import "golang.org/x/tools/cmd/toolstash"

import (
        "bufio"
        "flag"
        "fmt"
        "io"
        "io/ioutil"
        "log"
        "os"
        "os/exec"
        "path/filepath"
        "runtime"
        "strings"
        "time"
)

var usageMessage = `usage: toolstash [-n] [-v] [-cmp] command line

Examples:
        toolstash save
        toolstash restore
        toolstash go run x.go
        toolstash compile x.go
        toolstash -cmp compile x.go

For details, godoc golang.org/x/tools/cmd/toolstash
`

func usage() {
        fmt.Fprint(os.Stderr, usageMessage)
        os.Exit(2)
}

var (
        goCmd   = flag.String("go", "go", "path to \"go\" command")
        norun   = flag.Bool("n", false, "print but do not run commands")
        verbose = flag.Bool("v", false, "print commands being run")
        cmp     = flag.Bool("cmp", false, "compare tool object files")
        timing  = flag.Bool("t", false, "print time commands take")
)

var (
        cmd       []string
        tool      string // name of tool: "go", "compile", etc
        toolStash string // path to stashed tool

        goroot   string
        toolDir  string
        stashDir string
        binDir   string
)

func canCmp(name string, args []string) bool {
        switch name {
        case "asm", "compile", "link":
                if len(args) == 1 && (args[0] == "-V" || strings.HasPrefix(args[0], "-V=")) {
                        // cmd/go uses "compile -V=full" to query the tool's build ID.
                        return false
                }
                return true
        }
        return len(name) == 2 && '0' <= name[0] && name[0] <= '9' && (name[1] == 'a' || name[1] == 'g' || name[1] == 'l')
}

var binTools = []string{"go", "godoc", "gofmt"}

func isBinTool(name string) bool {
        return strings.HasPrefix(name, "go")
}

func main() {
        log.SetFlags(0)
        log.SetPrefix("toolstash: ")

        flag.Usage = usage
        flag.Parse()
        cmd = flag.Args()

        if len(cmd) < 1 {
                usage()
        }

        s, err := exec.Command(*goCmd, "env", "GOROOT").CombinedOutput()
        if err != nil {
                log.Fatalf("%s env GOROOT: %v", *goCmd, err)
        }
        goroot = strings.TrimSpace(string(s))
        toolDir = filepath.Join(goroot, fmt.Sprintf("pkg/tool/%s_%s", runtime.GOOS, runtime.GOARCH))
        stashDir = filepath.Join(goroot, "pkg/toolstash")

        binDir = os.Getenv("GOBIN")
        if binDir == "" {
                binDir = filepath.Join(goroot, "bin")
        }

        switch cmd[0] {
        case "save":
                save()
                return

        case "restore":
                restore()
                return
        }

        tool = cmd[0]
        if i := strings.LastIndexAny(tool, `/\`); i >= 0 {
                tool = tool[i+1:]
        }

        if !strings.HasPrefix(tool, "a.out") {
                toolStash = filepath.Join(stashDir, tool)
                if _, err := os.Stat(toolStash); err != nil {
                        log.Print(err)
                        os.Exit(2)
                }

                if *cmp && canCmp(tool, cmd[1:]) {
                        compareTool()
                        return
                }
                cmd[0] = toolStash
        }

        if *norun {
                fmt.Printf("%s\n", strings.Join(cmd, " "))
                return
        }
        if *verbose {
                log.Print(strings.Join(cmd, " "))
        }
        xcmd := exec.Command(cmd[0], cmd[1:]...)
        xcmd.Stdin = os.Stdin
        xcmd.Stdout = os.Stdout
        xcmd.Stderr = os.Stderr
        err = xcmd.Run()
        if err != nil {
                log.Fatal(err)
        }
        os.Exit(0)
}

func compareTool() {
        if !strings.Contains(cmd[0], "/") && !strings.Contains(cmd[0], `\`) {
                cmd[0] = filepath.Join(toolDir, tool)
        }

        outfile, ok := cmpRun(false, cmd)
        if ok {
                os.Remove(outfile + ".stash")
                return
        }

        extra := "-S=2"
        switch {
        default:
                log.Fatalf("unknown tool %s", tool)

        case tool == "compile" || strings.HasSuffix(tool, "g"): // compiler
                useDashN := true
                dashcIndex := -1
                for i, s := range cmd {
                        if s == "-+" {
                                // Compiling runtime. Don't use -N.
                                useDashN = false
                        }
                        if strings.HasPrefix(s, "-c=") {
                                dashcIndex = i
                        }
                }
                cmdN := injectflags(cmd, nil, useDashN)
                _, ok := cmpRun(false, cmdN)
                if !ok {
                        if useDashN {
                                log.Printf("compiler output differs, with optimizers disabled (-N)")
                        } else {
                                log.Printf("compiler output differs")
                        }
                        if dashcIndex >= 0 {
                                cmd[dashcIndex] = "-c=1"
                        }
                        cmd = injectflags(cmd, []string{"-v", "-m=2"}, useDashN)
                        break
                }
                if dashcIndex >= 0 {
                        cmd[dashcIndex] = "-c=1"
                }
                cmd = injectflags(cmd, []string{"-v", "-m=2"}, false)
                log.Printf("compiler output differs, only with optimizers enabled")

        case tool == "asm" || strings.HasSuffix(tool, "a"): // assembler
                log.Printf("assembler output differs")

        case tool == "link" || strings.HasSuffix(tool, "l"): // linker
                log.Printf("linker output differs")
                extra = "-v=2"
        }

        cmdS := injectflags(cmd, []string{extra}, false)
        outfile, _ = cmpRun(true, cmdS)

        fmt.Fprintf(os.Stderr, "\n%s\n", compareLogs(outfile))
        os.Exit(2)
}

func injectflags(cmd []string, extra []string, addDashN bool) []string {
        x := []string{cmd[0]}
        if addDashN {
                x = append(x, "-N")
        }
        x = append(x, extra...)
        x = append(x, cmd[1:]...)
        return x
}

func cmpRun(keepLog bool, cmd []string) (outfile string, match bool) {
        cmdStash := make([]string, len(cmd))
        copy(cmdStash, cmd)
        cmdStash[0] = toolStash
        for i, arg := range cmdStash {
                if arg == "-o" {
                        outfile = cmdStash[i+1]
                        cmdStash[i+1] += ".stash"
                        break
                }
                if strings.HasSuffix(arg, ".s") || strings.HasSuffix(arg, ".go") && '0' <= tool[0] && tool[0] <= '9' {
                        outfile = filepath.Base(arg[:strings.LastIndex(arg, ".")] + "." + tool[:1])
                        cmdStash = append([]string{cmdStash[0], "-o", outfile + ".stash"}, cmdStash[1:]...)
                        break
                }
        }

        if outfile == "" {
                log.Fatalf("cannot determine output file for command: %s", strings.Join(cmd, " "))
        }

        if *norun {
                fmt.Printf("%s\n", strings.Join(cmd, " "))
                fmt.Printf("%s\n", strings.Join(cmdStash, " "))
                os.Exit(0)
        }

        out, err := runCmd(cmd, keepLog, outfile+".log")
        if err != nil {
                log.Printf("running: %s", strings.Join(cmd, " "))
                os.Stderr.Write(out)
                log.Fatal(err)
        }

        outStash, err := runCmd(cmdStash, keepLog, outfile+".stash.log")
        if err != nil {
                log.Printf("running: %s", strings.Join(cmdStash, " "))
                log.Printf("installed tool succeeded but stashed tool failed.\n")
                if len(out) > 0 {
                        log.Printf("installed tool output:")
                        os.Stderr.Write(out)
                }
                if len(outStash) > 0 {
                        log.Printf("stashed tool output:")
                        os.Stderr.Write(outStash)
                }
                log.Fatal(err)
        }

        return outfile, sameObject(outfile, outfile+".stash")
}

func sameObject(file1, file2 string) bool {
        f1, err := os.Open(file1)
        if err != nil {
                log.Fatal(err)
        }
        defer f1.Close()

        f2, err := os.Open(file2)
        if err != nil {
                log.Fatal(err)
        }
        defer f2.Close()

        b1 := bufio.NewReader(f1)
        b2 := bufio.NewReader(f2)

        // Go object files and archives contain lines of the form
        //      go object <goos> <goarch> <version>
        // By default, the version on development branches includes
        // the Git hash and time stamp for the most recent commit.
        // We allow the versions to differ.
        if !skipVersion(b1, b2, file1, file2) {
                return false
        }

        lastByte := byte(0)
        for {
                c1, err1 := b1.ReadByte()
                c2, err2 := b2.ReadByte()
                if err1 == io.EOF && err2 == io.EOF {
                        return true
                }
                if err1 != nil {
                        log.Fatalf("reading %s: %v", file1, err1)
                }
                if err2 != nil {
                        log.Fatalf("reading %s: %v", file2, err1)
                }
                if c1 != c2 {
                        return false
                }
                if lastByte == '`' && c1 == '\n' {
                        if !skipVersion(b1, b2, file1, file2) {
                                return false
                        }
                }
                lastByte = c1
        }
}

func skipVersion(b1, b2 *bufio.Reader, file1, file2 string) bool {
        // Consume "go object " prefix, if there.
        prefix := "go object "
        for i := 0; i < len(prefix); i++ {
                c1, err1 := b1.ReadByte()
                c2, err2 := b2.ReadByte()
                if err1 == io.EOF && err2 == io.EOF {
                        return true
                }
                if err1 != nil {
                        log.Fatalf("reading %s: %v", file1, err1)
                }
                if err2 != nil {
                        log.Fatalf("reading %s: %v", file2, err1)
                }
                if c1 != c2 {
                        return false
                }
                if c1 != prefix[i] {
                        return true // matching bytes, just not a version
                }
        }

        // Keep comparing until second space.
        // Must continue to match.
        // If we see a \n, it's not a version string after all.
        for numSpace := 0; numSpace < 2; {
                c1, err1 := b1.ReadByte()
                c2, err2 := b2.ReadByte()
                if err1 == io.EOF && err2 == io.EOF {
                        return true
                }
                if err1 != nil {
                        log.Fatalf("reading %s: %v", file1, err1)
                }
                if err2 != nil {
                        log.Fatalf("reading %s: %v", file2, err1)
                }
                if c1 != c2 {
                        return false
                }
                if c1 == '\n' {
                        return true
                }
                if c1 == ' ' {
                        numSpace++
                }
        }

        // Have now seen 'go object goos goarch ' in both files.
        // Now they're allowed to diverge, until the \n, which
        // must be present.
        for {
                c1, err1 := b1.ReadByte()
                if err1 == io.EOF {
                        log.Fatalf("reading %s: unexpected EOF", file1)
                }
                if err1 != nil {
                        log.Fatalf("reading %s: %v", file1, err1)
                }
                if c1 == '\n' {
                        break
                }
        }
        for {
                c2, err2 := b2.ReadByte()
                if err2 == io.EOF {
                        log.Fatalf("reading %s: unexpected EOF", file2)
                }
                if err2 != nil {
                        log.Fatalf("reading %s: %v", file2, err2)
                }
                if c2 == '\n' {
                        break
                }
        }

        // Consumed "matching" versions from both.
        return true
}

func runCmd(cmd []string, keepLog bool, logName string) (output []byte, err error) {
        if *verbose {
                log.Print(strings.Join(cmd, " "))
        }

        if *timing {
                t0 := time.Now()
                defer func() {
                        log.Printf("%.3fs elapsed # %s\n", time.Since(t0).Seconds(), strings.Join(cmd, " "))
                }()
        }

        xcmd := exec.Command(cmd[0], cmd[1:]...)
        if !keepLog {
                return xcmd.CombinedOutput()
        }

        f, err := os.Create(logName)
        if err != nil {
                log.Fatal(err)
        }
        fmt.Fprintf(f, "GOOS=%s GOARCH=%s %s\n", os.Getenv("GOOS"), os.Getenv("GOARCH"), strings.Join(cmd, " "))
        xcmd.Stdout = f
        xcmd.Stderr = f
        defer f.Close()
        return nil, xcmd.Run()
}

func save() {
        if err := os.MkdirAll(stashDir, 0777); err != nil {
                log.Fatal(err)
        }

        toolDir := filepath.Join(goroot, fmt.Sprintf("pkg/tool/%s_%s", runtime.GOOS, runtime.GOARCH))
        files, err := ioutil.ReadDir(toolDir)
        if err != nil {
                log.Fatal(err)
        }

        for _, file := range files {
                if shouldSave(file.Name()) && file.Mode().IsRegular() {
                        cp(filepath.Join(toolDir, file.Name()), filepath.Join(stashDir, file.Name()))
                }
        }

        for _, name := range binTools {
                if !shouldSave(name) {
                        continue
                }
                src := filepath.Join(binDir, name)
                if _, err := os.Stat(src); err == nil {
                        cp(src, filepath.Join(stashDir, name))
                }
        }

        checkShouldSave()
}

func restore() {
        files, err := ioutil.ReadDir(stashDir)
        if err != nil {
                log.Fatal(err)
        }

        for _, file := range files {
                if shouldSave(file.Name()) && file.Mode().IsRegular() {
                        targ := toolDir
                        if isBinTool(file.Name()) {
                                targ = binDir
                        }
                        cp(filepath.Join(stashDir, file.Name()), filepath.Join(targ, file.Name()))
                }
        }

        checkShouldSave()
}

func shouldSave(name string) bool {
        if len(cmd) == 1 {
                return true
        }
        ok := false
        for i, arg := range cmd {
                if i > 0 && name == arg {
                        ok = true
                        cmd[i] = "DONE"
                }
        }
        return ok
}

func checkShouldSave() {
        var missing []string
        for _, arg := range cmd[1:] {
                if arg != "DONE" {
                        missing = append(missing, arg)
                }
        }
        if len(missing) > 0 {
                log.Fatalf("%s did not find tools: %s", cmd[0], strings.Join(missing, " "))
        }
}

func cp(src, dst string) {
        if *verbose {
                fmt.Printf("cp %s %s\n", src, dst)
        }
        data, err := ioutil.ReadFile(src)
        if err != nil {
                log.Fatal(err)
        }
        if err := ioutil.WriteFile(dst, data, 0777); err != nil {
                log.Fatal(err)
        }
}