//		If the package uses cgo or SWIG, these will be compiled with the
//		OS-native compiler (typically gcc); otherwise they will
//		trigger an error.
//	.cc, .cpp, .cxx, .hh, .hpp, .hxx
//		C++ source files. Only useful with cgo or SWIG, and always
//		compiled with the OS-native compiler.
//	.m
//		Objective-C source files. Only useful with cgo, and always
//		compiled with the OS-native compiler.
//	.s, .S, .sx

    }
    javaLauncher = launcher
    if (jvmVersionForTest().canCompileOrRun(9)) {
        // Required by JdkTools and JdkJavaCompiler
        jvmArgs(listOf("--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED"))
        jvmArgs(listOf("--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED"))

        if (isUnitTest() || usesEmbeddedExecuter()) {
            jvmArgs(org.gradle.internal.jvm.JpmsConfiguration.GRADLE_DAEMON_JPMS_ARGS)

		}
	}
	appendSetting("-buildmode", buildmode)
	appendSetting("-compiler", cfg.BuildContext.Compiler)
	if gccgoflags := BuildGccgoflags.String(); gccgoflags != "" && cfg.BuildContext.Compiler == "gccgo" {
		appendSetting("-gccgoflags", gccgoflags)
	}
	if gcflags := BuildGcflags.String(); gcflags != "" && cfg.BuildContext.Compiler == "gc" {
		appendSetting("-gcflags", gcflags)
	}

        }
    }
}
// end::executables[]

// tag::compiler-args[]
model {
    binaries {
        all {
            // Define toolchain-specific compiler and linker options
            if (toolChain in Gcc) {
                cCompiler.args "-O2"
                linker.args "-Xlinker", "-S"
            }
            if (toolChain in VisualCpp) {
                cCompiler.args "/Zi"
                linker.args "/DEBUG"

#define TENSORFLOW_COMPILER_JIT_TF_GRAPH_TO_HLO_COMPILER_H_

#include <memory>
#include <vector>

#include "tensorflow/compiler/jit/tf_to_hlo_compiler.h"
#include "tensorflow/compiler/tf2xla/xla_compiler.h"
#include "tensorflow/compiler/tf2xla/xla_helpers.h"

namespace tensorflow {

class TfGraphToHloCompiler : public TfToHloCompiler {
 public:
  TfGraphToHloCompiler() = delete;

# This script runs can be used to emit (readable) compile tracing info when building go packages

# Before usage, `go clean -cache` is suggested, otherwise you will measure cached results.
# Cleanup: rm -f /tmp/golog; This will always append to the file so you should cleanup between each call.
# Usage (compile all tests only): `go test -exec=true -toolexec=$PWD/tools/go-compile-verbose ./...`

        GccCommandLineToolConfigurationInternal compiler = toolRegistry.getTool(compilerType);
        if (compiler == null) {
            return new ComponentNotFound<GccMetadata>("Tool " + compilerType.getToolName() + " is not available");
        }
        CommandLineToolSearchResult searchResult = toolSearchPath.locate(compiler.getToolType(), compiler.getExecutable());

    def platform = Mock(NativePlatformInternal)
    def platformToolChain = Mock(PlatformToolProvider)
    Compiler<CCompileSpec> cCompiler = Mock(Compiler)
    def pch = Mock(PreCompiledHeader)

    def setup() {
        cCompile = TestUtil.createTask(CCompile, project)
    }

    def "executes using the C Compiler"() {
        def sourceFile = temporaryFolder.createFile("sourceFile")
        def result = Mock(WorkResult)

        return versionAwareCompiler(outputCleaningCompiler);
    }

    @Override
    protected Compiler<CCompileSpec> createCCompiler() {
        CommandLineToolInvocationWorker commandLineTool = tool("C compiler", visualCpp.getCompilerExecutable());

Daniel Jakots <******@****.***> 1702948102 -0500