testenv.MustHaveGoRun(t)
	t.Parallel()

	const pkg = "example.com/pgo/devirtualize"

	// Add a go.mod so we have a consistent symbol names in this temp dir.
	goMod := fmt.Sprintf(`module %s
go 1.21
`, pkg)
	if err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte(goMod), 0644); err != nil {
		t.Fatalf("error writing go.mod: %v", err)
	}

	// Run the test without PGO to ensure that the test assertions are

        GOTOOLDIR="/usr/local/go/pkg/tool/darwin_arm64"
        GOVCS=""
        GOVERSION="go1.20.7"
        GCCGO="gccgo"
        AR="ar"
        CC="clang"
        CXX="clang++"
        CGO_ENABLED="1"
        GOMOD="/dev/null"
        GOWORK=""
        CGO_CFLAGS="-O2 -g"
        CGO_CPPFLAGS=""
        CGO_CXXFLAGS="-O2 -g"
        CGO_FFLAGS="-O2 -g"
        CGO_LDFLAGS="-O2 -g"
        PKG_CONFIG="pkg-config"

				if os.IsNotExist(err) {
					dir = parent
					continue
				}
				gorootErr = fmt.Errorf("finding GOROOT: %w", err)
				return
			}
			goMod := string(b)

			for goMod != "" {
				var line string
				line, goMod, _ = strings.Cut(goMod, "\n")
				fields := strings.Fields(line)
				if len(fields) >= 2 && fields[0] == "module" && fields[1] == "std" {

		// a bogus file for an invalid version.
		_, err := r.Stat(ctx, version)
		if err != nil {
			return nil, err
		}
	}

	rev, dir, gomod, err := r.findDir(ctx, version)
	if err != nil {
		return nil, err
	}
	if gomod != nil {
		return gomod, nil
	}
	data, err = r.code.ReadFile(ctx, rev, path.Join(dir, "go.mod"), codehost.MaxGoMod)
	if err != nil {
		if os.IsNotExist(err) {

	Indirect   bool             `json:",omitempty"` // module is only indirectly needed by main module
	Dir        string           `json:",omitempty"` // directory holding local copy of files, if any
	GoMod      string           `json:",omitempty"` // path to go.mod file describing module, if any
	GoVersion  string           `json:",omitempty"` // go version used in module

        Query    string // version query corresponding to this version
        Version  string // module version
        Error    string // error loading module
        Info     string // absolute path to cached .info file
        GoMod    string // absolute path to cached .mod file
        Zip      string // absolute path to cached .zip file
        Dir      string // absolute path to cached source root directory

	const pkg = "example.com/pgo/inline"

	// Add a go.mod so we have a consistent symbol names in this temp dir.
	goMod := fmt.Sprintf(`module %s
go 1.19
`, pkg)
	if err := os.WriteFile(filepath.Join(dir, "go.mod"), []byte(goMod), 0644); err != nil {
		t.Fatalf("error writing go.mod: %v", err)
	}

	exe := filepath.Join(dir, "test.exe")

	}
	var max string
	for _, v := range versions.List {
		if max == "" || gover.ModCompare(r.path, v, max) > 0 {
			max = v
		}
	}
	return r.Stat(ctx, max)
}

func (r *toolchainRepo) GoMod(ctx context.Context, version string) (data []byte, err error) {
	return []byte("module " + r.path + "\n"), nil
}

func (r *toolchainRepo) Zip(ctx context.Context, dst io.Writer, version string) error {

	}
	return info, nil
}

func (p *proxyRepo) GoMod(ctx context.Context, version string) ([]byte, error) {
	if version != module.CanonicalVersion(version) {
		return nil, p.versionError(version, fmt.Errorf("internal error: version passed to GoMod is not canonical"))
	}

	encVer, err := module.EscapeVersion(version)
	if err != nil {

)

func main() {
	exe := os.Args[1]
	data, err := ioutil.ReadFile(exe)
	if err != nil {
		log.Fatal(err)
	}

	if os.Getenv("GO111MODULE") == "on" {
		out, err := exec.Command("go", "env", "GOMOD").Output()
		if err != nil {
			log.Fatal(err)
		}
		modRoot := filepath.Dir(strings.TrimSpace(string(out)))
		check(data, "module root", modRoot)
	} else {
		check(data, "GOPATH", os.Getenv("GOPATH"))
	}