import com.google.common.collect.ImmutableMultimap;

/**
 * File types used in Apple targets.
 */
public enum FileTypes {
    /**
     * Apple UTI for executables.
     */
    MACH_O_EXECUTABLE("", "compiled.mach-o.executable"),

    /**
     * Apple UTI for dynamic libraries.
     */
    MACH_O_DYNAMIC_LIBRARY("dylib", "compiled.mach-o.dylib"),

    /**
     * Apple UTI for static libraries.

    HelloWorldApp app = new CppHelloWorldApp()

    @Requires(UnitTestPreconditions.CanInstallExecutable)
    @ToBeFixedForConfigurationCache
    def "can produce multiple executables that use a library from a single project in parallel"() {
        given:
        def apps = [
            first : new ExeWithLibraryUsingLibraryHelloWorldApp(),
            second: new ExeWithLibraryUsingLibraryHelloWorldApp(),

                task.getExecutableFile().set(executable.getExecutableFile());
                task.lib(executable.getRuntimeLibraries());
            });

            executable.getInstallTask().set(install);
            executable.getInstallDirectory().set(install.flatMap(task -> task.getInstallDirectory()));
            executable.getOutputs().from(executable.getInstallDirectory());

		Set build mode (default exe).
	-c
		Dump call graphs.
	-compressdwarf
		Compress DWARF if possible (default true).
	-cpuprofile file
		Write CPU profile to file.
	-d
		Disable generation of dynamic executables.
		The emitted code is the same in either case; the option
		controls only whether a dynamic header is included.
		The dynamic header is on by default, even without any
		references to dynamic libraries, because many common

  const XlaCompiler::CompilationResult* result;
  xla::PjRtLoadedExecutable* executable;
  CompileToExecutable(args, &result, &executable);

  std::vector<const Tensor*> inputs;
  inputs.push_back(a);
  inputs.push_back(b);
  TF_ASSERT_OK_AND_ASSIGN(auto execute_outputs,
                          RunExecutable(inputs, {}, result, executable));

  TF_EXPECT_OK(PopulateCtxOutputsFromPjRtExecutableOutputs(

  However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library".  The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.

  When a "work that uses the Library" uses material from a header file

    }

    def "is compatible with same executable"() {
        def other = new DefaultJavaForkOptions(resolver, fileCollectionFactory, new DefaultJavaDebugOptions())

        when:
        options.executable = "foo"
        other.executable = "foo"

        then:
        options.isCompatibleWith(other)
    }

    def "is not compatible with different executables"() {

executable to an output file named after the last non-major-version
component of the package import path. The '.exe' suffix is added
when writing a Windows executable.
So 'go build example/sam' writes 'sam' or 'sam.exe'.
'go build example.com/foo/v2' writes 'foo' or 'foo.exe', not 'v2.exe'.

When compiling a package from a list of .go files, the executable
is named after the first source file.

	}

	return nil, fmt.Errorf("unrecognized executable format")
}

func must(err error) {
	if err != nil {
		panic(err)
	}
}

type Line struct {
	File string
	Line int
}

func TestStmtLines(t *testing.T) {
	if !platform.ExecutableHasDWARF(runtime.GOOS, runtime.GOARCH) {
		t.Skipf("skipping on %s/%s: no DWARF symbol table in executables", runtime.GOOS, runtime.GOARCH)
	}

[[sec:building_an_executable]]
== Building an executable

To build a native executable, you define an executable component in the `components` container. The following sample defines an executable called `main`:

=== Example: Defining executable components

[source.multi-language-sample,groovy]
.build.gradle
----
include::{snippetsPath}/native-binaries/c/groovy/build.gradle[tag=executables]
----