return 0, nil
	}

	switch fh.Type {
	case elf.ET_EXEC:
		if loadSegment == nil {
			// Assume fixed-address executable and so no adjustment.
			return 0, nil
		}
		if stextOffset == nil && start > 0 && start < 0x8000000000000000 {
			// A regular user-mode executable. Compute the base offset using same
			// arithmetics as in ET_DYN case below, see the explanation there.

                if (exe.isAbsolute()) {
                    builder.executable(exe.getAbsolutePath());
                } else {
                    builder.executable(String.format("%s/%s", getWorkingDir().getAbsolutePath(), getExecutable()));
                }
            } else {
                builder.executable(String.format("%s/bin/gradle", getDistribution().getGradleHomeDir().getAbsolutePath()));
            }

Depends on: All tasks which contribute to the link executable, including `link__Variant__` and `create__Variant__` tasks from projects that are resolved via project dependencies and tested component
::
Links executable from compiled object files using the selected linker.

            group = 'org.gradle'
            version = '2.0'

            dependencies {
                implementation "org.test:greeter:latest.integration"
            }
        """
        fixture.executable.writeToProject(testDirectory)

        when:
        succeeds ':xcode'

        then:
        result.assertTasksExecuted(":greeter:compileDebugSwift",

    /**
     * {@inheritDoc}
     */
    @Override
    public Test executable(Object executable) {
        forkOptions.executable(executable);
        return this;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void setExecutable(String executable) {
        forkOptions.setExecutable(executable);
    }

    /**
     * {@inheritDoc}
     */
    @Override

	"slices"
	"strings"
	"testing"
)

func init() {
	registerHelperCommand("printpath", cmdPrintPath)
}

func cmdPrintPath(args ...string) {
	exe, err := os.Executable()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Executable: %v\n", err)
		os.Exit(1)
	}
	fmt.Println(exe)
}

// makePATH returns a PATH variable referring to the
// given directories relative to a root directory.
//

which the executable runs, unless that component itself accompanies
the executable.

  It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system.  Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.

        os.getScriptName("a") == "a.bat"
        os.getScriptName("a.exe") == "a.bat"
        os.getScriptName("a.b/c") == "a.b/c.bat"
        os.getScriptName("a.b\\c") == "a.b\\c.bat"
    }

    def "windows transforms executable names"() {
        def os = new OperatingSystem.Windows()

        expect:
        os.executableSuffix == ".exe"
        os.getExecutableName("a.exe") == "a.exe"
        os.getExecutableName("a.EXE") == "a.EXE"

        def currentJdk = Jvm.current()
        def otherJdk = AvailableJavaHomes.getDifferentVersion()

        if (option == "executable") {
            buildFile << """
                compileScala {
                    options.fork = true
                    options.forkOptions.executable = "${TextUtil.normaliseFileSeparators(otherJdk.javaExecutable.absolutePath)}"
                }
            """
        } else {

        def currentJdk = Jvm.current()
        def otherJdk = AvailableJavaHomes.getDifferentVersion()

        if (option == "executable") {
            buildFile << """
                compileGroovy {
                    options.fork = true
                    options.forkOptions.executable = "${TextUtil.normaliseFileSeparators(otherJdk.javaExecutable.absolutePath)}"
                }
            """
        } else {