toRet.add(fact.createToolchain(tm));
                }
            }

            // add default toolchain
            ToolchainPrivate tool = fact.createDefaultToolchain();
            if (tool != null) {
                toRet.add(tool);
            }
        }

        return toRet.toArray(new ToolchainPrivate[0]);
    }

    @Override

    }

    void assertDoesNotExist() {
        file.assertDoesNotExist()
    }

    // Does nothing when tool chain does not generate a separate debug file
    void assertDebugFileExists() {
        if (toolChain.visualCpp) {
            getSymbolFile().assertIsFile()
        }
    }

    // Does nothing when tool chain does not generate a separate debug file
    void assertDebugFileDoesNotExist() {
        if (toolChain.visualCpp) {

                    // TODO: should use target platform to make this decision
                    if (OperatingSystem.current().isMacOsX()) {
                        execSpec.executable("ld"); // TODO: Locate this tool from a tool provider
                        execSpec.args(object);
                        execSpec.args("-o", relocatedObject);
                        execSpec.args("-r"); // relink, produce another object file

The -fix flag sets a comma-separated list of fixes to run.
The default is all known fixes.
(Its value is passed to 'go tool fix -r'.)

For more about fix, see 'go doc cmd/fix'.
For more about specifying packages, see 'go help packages'.

To run fix with other options, run 'go tool fix'.

See also: go fmt, go vet.
	`,
}

var fixes = CmdFix.Flag.String("fix", "", "comma-separated list of fixes to apply")

			defer tmp.Close()
			for i := 0; i < iters; i++ {
				// Note: use -c 2 to expose any nondeterminism which is the result
				// of the runtime scheduler.
				out, err := testenv.Command(t, testenv.GoToolPath(t), "tool", "compile", "-p=p", "-c", "2", "-o", tmp.Name(), filepath.Join("testdata", "reproducible", test)).CombinedOutput()
				if err != nil {
					t.Fatalf("failed to compile: %v\n%s", err, out)
				}

env GOROOT=$WORK/goroot2
symlink $GOROOT -> $TESTGO_GOROOT

env GOCACHE=$WORK/gocache2
mkdir $GOCACHE

go build -o binary2 -trimpath -x main.go

# Check that the binaries match exactly
go tool buildid binary1
cp stdout buildid1
go tool buildid binary2
cp stdout buildid2
cmp buildid1 buildid2


-- main.go --
package main

L8:@echo off
L9:
L10:setlocal
L11:
L12:if exist make.bat goto ok
L13:echo race.bat must be run from go\src
L14::: cannot exit: would kill parent command interpreter
L15:goto end
L16::ok
L17:
L18:set GOROOT=%CD%\..
L19:call .\make.bat --dist-tool >NUL
L20:if errorlevel 1 goto fail
L21:.\cmd\dist\dist.exe env -w -p >env.bat
L22:if errorlevel 1 goto fail
L23:call .\env.bat
L24:del env.bat
L25:
L26:if %GOHOSTARCH% == amd64 goto continue
L27:echo Race detector is only supported on windows/amd64.
...

//
//	-V=full         describe executable               (to the build tool)
//	-flags          describe flags                    (to the build tool)
//	foo.cfg         description of compilation unit (from the build tool)
//
// This package does not depend on go/packages.
// If you need a standalone tool, use multichecker,
// which supports this mode but can also load packages
// from source using go/packages.

//
// # Usage examples
//
// Use the pprof tool to look at the heap profile:
//
//	go tool pprof http://localhost:6060/debug/pprof/heap
//
// Or to look at a 30-second CPU profile:
//
//	go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30
//
// Or to look at the goroutine blocking profile, after calling
// [runtime.SetBlockProfileRate] in your program:
//
//	go tool pprof http://localhost:6060/debug/pprof/block
//

import org.gradle.api.Incubating;
import org.gradle.nativeplatform.platform.NativePlatform;

/**
 * A platform specific configurable tool chain.
 */
@Incubating
public interface NativePlatformToolChain {
    /**
     * Returns the platform which this tool chain builds for.
     */
    NativePlatform getPlatform();