architecture "x86_64"
        }
    }
    components {
        exe(NativeExecutableSpec) {
            targetPlatform "x86"
            sources {
                cpp.lib library: "hello", linkage: "static"
            }
        }
        hello(NativeLibrarySpec) {
            targetPlatform "x86"
        }
    }
}
"""

        and:
        succeeds "exeExecutable"

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"))

    def "can create xcode project for Swift static library"() {
        requireSwiftToolChain()

        given:
        buildFile << """
            apply plugin: 'swift-library'
            library.linkage = [Linkage.STATIC]
        """
        def lib = new SwiftLib()
        lib.writeToProject(testDirectory)

        when:
        succeeds("xcode")

        then:

"""
        addGoogleTestDep()
    }

    private void addGoogleTestDep() {
        buildFile << """
model {
    binaries {
        withType(GoogleTestTestSuiteBinarySpec) {
            lib library: "googleTest", linkage: "static"
            if (targetPlatform.operatingSystem.linux) {
                cppCompiler.args '-pthread'
                linker.args '-pthread'
            }

            rootProject.name = 'lib'
        """
        buildFile << """
            apply plugin: 'cpp-library'
            library {
                baseName = 'some-lib'
                linkage = [Linkage.STATIC, Linkage.SHARED]
                privateHeaders.from = []
                publicHeaders.from = ['include']
                binaries.configureEach(CppSharedLibrary) {

                (Attribute.of("linkage", SomeEnum)): SomeEnum.VALUE_1)
        def v2 = Stub(UsageContext)
        v2.name >> "v2"
        v2.attributes >> attributesTyped(
                (Attribute.of("usage", String)): "runtime",
                (Attribute.of("debuggable", Boolean)): true,
                (Attribute.of("platform", Named)): platform,
                (Attribute.of("linkage", SomeEnum)): SomeEnum.VALUE_2)

// An empty list means `op` is not exported.
SmallVector<StringRef, 2> GetExportedNames(Operation *op);

// Returns true if `op` is exported.
bool IsExported(Operation *op);

// Returns true if `module` has tf_saved_model linkage semantics.
bool HasTfSavedModelSemantics(ModuleOp module_op);

// Returns the tf_saved_model.global_tensor op that func's arg_index'th argument
// refers to as a bound input, or null.

	XMC_RO     = 1  // Read-only constant
	XMC_DB     = 2  // Debug dictionary table
	XMC_TC     = 3  // TOC entry
	XMC_UA     = 4  // Unclassified
	XMC_RW     = 5  // Read/Write data
	XMC_GL     = 6  // Global linkage
	XMC_XO     = 7  // Extended operation
	XMC_SV     = 8  // 32-bit supervisor call descriptor
	XMC_BS     = 9  // BSS class
	XMC_DS     = 10 // Function descriptor
	XMC_UC     = 11 // Unnamed FORTRAN common

                    linkTask.get().linkerArgs.add("-lc++")
                }
            }
            project(':cppGreeter') {
                apply plugin: 'cpp-library'
                library.linkage = [Linkage.STATIC]
            }
        """
        swiftGreeter.writeToProject(file("hello"))
        cppGreeter.asLib().writeToProject(file("cppGreeter"))
        sumLibrary.writeToProject(file("app"))

DEFINE_PPC64X_FUNCDESC(main, _main)
TEXT _main(SB),NOSPLIT,$-8
	MOVD $runtime·rt0_go(SB), R12
	MOVD R12, CTR
	BR (CTR)


TEXT _rt0_ppc64_aix_lib(SB),NOSPLIT,$-8
	// Start with standard C stack frame layout and linkage.
	MOVD	LR, R0
	MOVD	R0, 16(R1) // Save LR in caller's frame.
	MOVW	CR, R0	   // Save CR in caller's frame
	MOVD	R0, 8(R1)

	MOVDU	R1, -344(R1) // Allocate frame.

	// Preserve callee-save registers.