apply plugin: 'c'

model {
    toolChains {
        ${toolChain.buildScriptConfig}
    }
    components {
        main(NativeExecutableSpec) {
            binaries.all {
                lib library: 'hello', linkage: 'static'
            }
        }
        hello(NativeLibrarySpec)
    }
}
"""

        helloWorldApp.executable.writeSources(file("src/main"))
        helloWorldApp.library.writeSources(file("src/hello"))

     */
    String getBaseName();

    /**
     * Returns the compilation details.
     */
    CompilationDetails getCompilationDetails();

    /**
     * Returns the linkage details.
     */
    LinkageDetails getLinkageDetails();

    cppApplication_xcodeProject[label="xcodeProject"]
  }

  subgraph cluster_cppLibrary {
    label = "C++ Library Plugin\n(shared or static linkage)"

    {cppLibrary_xcodeScheme, cppLibrary_xcodeProjectWorkspaceSettings} -> cppLibrary_xcodeProject [dir=back]

    cppLibrary_xcodeScheme[label="xcodeScheme"]

  compileVariantSwift[label=<compile<i>Variant</i>Swift>]
  linkVariant[label=<link<i>Variant</i>>]
  createVariant[label=<create<i>Variant</i>>]
  assembleVariant[label=<assemble<i>Variant</i>>]

  // Adds linkage text between link* and create*
  linkVariant -> linkageText -> createVariant [style=invis]
  {rank=same linkVariant linkageText createVariant}
  linkageText[shape=plain, label="and/or\n(see note)"]

  compileVariantCpp[label=<compile<i>Variant</i>Cpp>]
  linkVariant[label=<link<i>Variant</i>>]
  createVariant[label=<create<i>Variant</i>>]
  assembleVariant[label=<assemble<i>Variant</i>>]

  // Adds linkage text between link* and create*
  linkVariant -> linkageText -> createVariant [style=invis]
  {rank=same linkVariant linkageText createVariant}
  linkageText[shape=plain, label="and/or\n(see note)"]

import org.gradle.api.model.ObjectFactory;
import org.gradle.api.provider.Property;
import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.OutputFile;
import org.gradle.api.tasks.TaskAction;
import org.gradle.nativeplatform.Linkage;
import org.gradle.swiftpm.Package;
import org.gradle.swiftpm.internal.AbstractProduct;
import org.gradle.swiftpm.internal.BranchDependency;
import org.gradle.swiftpm.internal.DefaultLibraryProduct;

    }
    testSuites {
        helloTest(CUnitTestSuiteSpec) {
            testing \$.components.hello
        }
    }
    binaries {
        withType(CUnitTestSuiteBinarySpec) {
            lib library: "cunit", linkage: "static"
        }
    }
}
"""
    }

    private def getCunitLibName() {
        return OperatingSystem.current().getStaticLibraryName("cunit")
    }

    @ToBeFixedForConfigurationCache

// Saves C callee-saved registers and calls cgocallback with three arguments.
// fn is the PC of a func(a unsafe.Pointer) function.
TEXT crosscall2(SB),NOSPLIT|NOFRAME,$0
	// Start with standard C stack frame layout and linkage.

	// Save R6-R15 in the register save area of the calling function.
	STMG	R6, R15, 48(R15)

	// Allocate 96 bytes on the stack.
	MOVD	$-96(R15), R15

	// Save F8-F15 in our stack frame.
	FMOVD	F8, 32(R15)

	but it's standard and should be very efficient.

	GCC 7 has an unfortunate habit of optimizing out strncpy calls (see
	https://golang.org/issue/21196), so the arguments here need to be global
	variables with external linkage in order to ensure that the call traps all the
	way down into libc.
	*/
	strncpy(&x_cgo_yield_strncpy_dst, &x_cgo_yield_strncpy_src,
	        x_cgo_yield_strncpy_n);
}

void(* const _cgo_yield)() = &x_cgo_yield;

        given:
        buildFile << """
apply plugin: 'c'

model {
    components {
        main(NativeExecutableSpec) {
            binaries.all {
                lib library: 'hello', linkage: 'api'

                def librarySearchPath = 'build/libs/hello/static'
                def libraryName = 'hello'
                if (toolChain in VisualCpp) {