[K/N] Separate ClangArgs for jni and native

Since LLVM for Windows is now native instead on MinGW, we have to compile code in a different environment in case of JNI. This commits just separates ClangArgs into two subclasses without actual behavior changes.
2026-03-10 08:31:29 +00:00 · 2021-07-23 12:04:07 +07:00
parent fbbbc1c092
commit a78fcd6b64
8 changed files with 61 additions and 41 deletions
--- a/kotlin-native/Interop/Indexer/build.gradle.kts
+++ b/kotlin-native/Interop/Indexer/build.gradle.kts
@@ -45,7 +45,7 @@ val libclang =

 val cflags = mutableListOf( "-I$llvmDir/include",
        "-I${project(":kotlin-native:libclangext").projectDir.absolutePath}/src/main/include",
-                            *platformManager.hostPlatform.clang.hostCompilerArgsForJni)
+                            *platformManager.hostPlatform.clangForJni.hostCompilerArgsForJni)

 val ldflags = mutableListOf("$llvmDir/$libclang", "-L${libclangextDir.absolutePath}", "-lclangext")

@@ -99,17 +99,15 @@ val lib = if (HostManager.hostIsMingw) "lib" else "a"

 native {
    val obj = if (HostManager.hostIsMingw) "obj" else "o"
-    val host = rootProject.project(":kotlin-native").extra["hostName"]
-    val hostLibffiDir = rootProject.project(":kotlin-native").extra["${host}LibffiDir"]
    val cxxflags = listOf("-std=c++11", *cflags.toTypedArray())
    suffixes {
        (".c" to ".$obj") {
-            tool(*platformManager.hostPlatform.clang.clangC("").toTypedArray())
+            tool(*platformManager.hostPlatform.clangForJni.clangC("").toTypedArray())
            flags(*cflags.toTypedArray(),
                  "-c", "-o", ruleOut(), ruleInFirst())
        }
        (".cpp" to ".$obj") {
-            tool(*platformManager.hostPlatform.clang.clangCXX("").toTypedArray())
+            tool(*platformManager.hostPlatform.clangForJni.clangCXX("").toTypedArray())
            flags(*cxxflags.toTypedArray(), "-c", "-o", ruleOut(), ruleInFirst())
        }

@@ -126,7 +124,7 @@ native {
                         sourceSets["main-cpp"]!!.transform(".cpp" to ".$obj"))

    target(solib("clangstubs"), *objSet) {
-        tool(*platformManager.hostPlatform.clang.clangCXX("").toTypedArray())
+        tool(*platformManager.hostPlatform.clangForJni.clangCXX("").toTypedArray())
        flags(
            "-shared",
            "-o", ruleOut(), *ruleInAll(),
--- a/kotlin-native/Interop/Runtime/build.gradle.kts
+++ b/kotlin-native/Interop/Runtime/build.gradle.kts
@@ -35,10 +35,10 @@ native {
    val host = rootProject.project(":kotlin-native").extra["hostName"]
    val hostLibffiDir = rootProject.project(":kotlin-native").extra["${host}LibffiDir"]
    val cflags = mutableListOf("-I$hostLibffiDir/include",
-                               *platformManager.hostPlatform.clang.hostCompilerArgsForJni)
+                               *platformManager.hostPlatform.clangForJni.hostCompilerArgsForJni)
    suffixes {
        (".c" to ".$obj") {
-            tool(*platformManager.hostPlatform.clang.clangC("").toTypedArray())
+            tool(*platformManager.hostPlatform.clangForJni.clangC("").toTypedArray())
            flags( *cflags.toTypedArray(), "-c", "-o", ruleOut(), ruleInFirst())
        }
    }
@@ -50,7 +50,7 @@ native {
    val objSet = sourceSets["callbacks"]!!.transform(".c" to ".$obj")

    target(solib("callbacks"), objSet) {
-        tool(*platformManager.hostPlatform.clang.clangCXX("").toTypedArray())
+        tool(*platformManager.hostPlatform.clangForJni.clangCXX("").toTypedArray())
        flags("-shared",
              "-o",ruleOut(), *ruleInAll(),
              "-L${project(":kotlin-native:libclangext").buildDir}",
--- a/kotlin-native/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/ToolConfig.kt
+++ b/kotlin-native/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/ToolConfig.kt
@@ -16,16 +16,13 @@

 package  org.jetbrains.kotlin.native.interop.tool

-import org.jetbrains.kotlin.konan.target.HostManager
-import org.jetbrains.kotlin.konan.target.KonanTarget
-import org.jetbrains.kotlin.konan.target.PlatformManager
-import org.jetbrains.kotlin.konan.target.customerDistribution
+import org.jetbrains.kotlin.konan.target.*
 import org.jetbrains.kotlin.konan.util.KonanHomeProvider
 import org.jetbrains.kotlin.konan.util.defaultTargetSubstitutions
 import org.jetbrains.kotlin.native.interop.gen.jvm.KotlinPlatform
 import org.jetbrains.kotlin.native.interop.indexer.Language

-class ToolConfig(userProvidedTargetName: String?, flavor: KotlinPlatform) {
+class ToolConfig(userProvidedTargetName: String?, private val flavor: KotlinPlatform) {

    private val konanHome = KonanHomeProvider.determineKonanHome()
    private val distribution = customerDistribution(konanHome)
@@ -36,7 +33,10 @@ class ToolConfig(userProvidedTargetName: String?, flavor: KotlinPlatform) {

    private val platform = platformManager.platform(target)

-    val clang = platform.clang
+    val clang = when (flavor) {
+        KotlinPlatform.JVM -> platform.clangForJni
+        KotlinPlatform.NATIVE -> platform.clang
+    }

    val substitutions = defaultTargetSubstitutions(target)

@@ -44,12 +44,12 @@ class ToolConfig(userProvidedTargetName: String?, flavor: KotlinPlatform) {

    fun getDefaultCompilerOptsForLanguage(language: Language): List<String> = when (language) {
        Language.C,
-        Language.OBJECTIVE_C -> platform.clang.libclangArgs.toList()
-        Language.CPP -> platform.clang.libclangXXArgs.toList()
+        Language.OBJECTIVE_C -> clang.libclangArgs.toList()
+        Language.CPP -> clang.libclangXXArgs.toList()
    }

-    val platformCompilerOpts = if (flavor == KotlinPlatform.JVM)
-            platform.clang.hostCompilerArgsForJni.toList() else emptyList()
+    val platformCompilerOpts = if (clang is ClangArgs.Jni)
+            clang.hostCompilerArgsForJni.toList() else emptyList()

    val llvmHome = platform.absoluteLlvmHome
    val sysRoot = platform.absoluteTargetSysRoot
--- a/kotlin-native/libclangext/build.gradle.kts
+++ b/kotlin-native/libclangext/build.gradle.kts
@@ -36,7 +36,7 @@ native {
    }
    suffixes {
        (".cpp" to ".$obj") {
-            tool(*platformManager.hostPlatform.clang.clangCXX("").toTypedArray())
+            tool(*platformManager.hostPlatform.clangForJni.clangCXX("").toTypedArray())
            flags(*cxxflags.toTypedArray(), "-c", "-o", ruleOut(), ruleInFirst())
        }
    }
@@ -47,7 +47,7 @@ native {
    }
    val objSet = sourceSets["main"]!!.transform(".cpp" to ".$obj")
    target(lib("clangext"), objSet) {
-        tool(*platformManager.hostPlatform.clang.llvmAr("").toTypedArray())
+        tool(*platformManager.hostPlatform.clangForJni.llvmAr("").toTypedArray())
        flags("-qv", ruleOut(), *ruleInAll())
    }
 }
--- a/kotlin-native/llvmCoverageMappingC/build.gradle.kts
+++ b/kotlin-native/llvmCoverageMappingC/build.gradle.kts
@@ -45,7 +45,7 @@ native {
    }
    suffixes {
        (".cpp" to ".$obj") {
-            tool(*platformManager.hostPlatform.clang.clangCXX("").toTypedArray())
+            tool(*platformManager.hostPlatform.clangForJni.clangCXX("").toTypedArray())
            flags(*cxxflags.toTypedArray(), "-c", "-o", ruleOut(), ruleInFirst())
        }

@@ -58,7 +58,7 @@ native {
    val objSet = sourceSets["main"]!!.transform(".cpp" to ".$obj")

    target(lib("coverageMapping"), objSet) {
-        tool(*platformManager.hostPlatform.clang.llvmAr("").toTypedArray())
+        tool(*platformManager.hostPlatform.clangForJni.llvmAr("").toTypedArray())
        flags("-qv", ruleOut(), *ruleInAll())
    }
 }
--- a/kotlin-native/llvmDebugInfoC/build.gradle.kts
+++ b/kotlin-native/llvmDebugInfoC/build.gradle.kts
@@ -28,8 +28,6 @@ val llvmDir = project.findProperty("llvmDir")

 native {
    val obj = if (HostManager.hostIsMingw) "obj" else "o"
-    val host = rootProject.project(":kotlin-native").extra["hostName"]
-    val hostLibffiDir = rootProject.project(":kotlin-native").extra["${host}LibffiDir"]
    val cxxflags = mutableListOf(
        "--std=c++17",
        "-I${llvmDir}/include",
@@ -37,7 +35,7 @@ native {
    )
    suffixes {
        (".cpp" to ".$obj") {
-            tool(*platformManager.hostPlatform.clang.clangCXX("").toTypedArray())
+            tool(*platformManager.hostPlatform.clangForJni.clangCXX("").toTypedArray())
            flags(*cxxflags.toTypedArray(), "-c", "-o", ruleOut(), ruleInFirst())
        }

@@ -50,7 +48,7 @@ native {
    val objSet = sourceSets["main"]!!.transform(".cpp" to ".$obj")

    target(lib("debugInfo"), objSet) {
-        tool(*platformManager.hostPlatform.clang.llvmAr("").toTypedArray())
+        tool(*platformManager.hostPlatform.clangForJni.llvmAr("").toTypedArray())
        flags("-qv", ruleOut(), *ruleInAll())
    }
 }
--- a/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/ClangArgs.kt
+++ b/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/ClangArgs.kt
@@ -31,7 +31,10 @@ internal object Android {
            "android-${API}/arch-${architectureMap.getValue(target)}"
 }

-class ClangArgs(private val configurables: Configurables) {
+sealed class ClangArgs(
+        private val configurables: Configurables,
+        private val forJni: Boolean
+) {

    private val absoluteTargetToolchain = configurables.absoluteTargetToolchain
    private val absoluteTargetSysRoot = configurables.absoluteTargetSysRoot
@@ -152,16 +155,6 @@ class ClangArgs(private val configurables: Configurables) {

    val clangPaths = listOf("$absoluteLlvmHome/bin", binDir)

-    private val jdkDir by lazy {
-        val home = File.javaHome.absoluteFile
-        if (home.child("include").exists)
-            home.absolutePath
-        else
-            home.parentFile.absolutePath
-    }
-
-    val hostCompilerArgsForJni = listOf("", HostManager.jniHostPlatformIncludeDir).map { "-I$jdkDir/include/$it" }.toTypedArray()
-
    /**
     * Clang args for Objectice-C and plain C compilation.
     */
@@ -224,5 +217,31 @@ class ClangArgs(private val configurables: Configurables) {
    fun clangCXX(vararg userArgs: String) = targetClangXXCmd + userArgs.asList()

    fun llvmAr(vararg userArgs: String) = targetArCmd + userArgs.asList()
+
+    /**
+     * Should be used when compiling library for JNI.
+     * For example, it is used for Kotlin/Native's Clang and LLVM libraries.
+     */
+    class Jni(configurables: Configurables) : ClangArgs(configurables, forJni = true) {
+        private val jdkDir by lazy {
+            val home = File.javaHome.absoluteFile
+            if (home.child("include").exists)
+                home.absolutePath
+            else
+                home.parentFile.absolutePath
+        }
+
+        val hostCompilerArgsForJni: Array<String> by lazy {
+            listOf("", HostManager.jniHostPlatformIncludeDir)
+                    .map { "-I$jdkDir/include/$it" }
+                    .toTypedArray()
+        }
+    }
+
+    /**
+     * Used for compiling native code that meant to be run on end-user's hardware.
+     * E.g., Kotlin/Native runtime and interop stubs.
+     */
+    class Native(configurables: Configurables) : ClangArgs(configurables, forJni = false)
 }

--- a/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Platform.kt
+++ b/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Platform.kt
@@ -21,10 +21,15 @@ import org.jetbrains.kotlin.konan.util.DependencyProcessor
 class Platform(val configurables: Configurables) 
    : Configurables by configurables {

-    val clang by lazy {
-        ClangArgs(configurables)
+    val clang: ClangArgs.Native by lazy {
+        ClangArgs.Native(configurables)
    }
-    val linker by lazy {
+
+    val clangForJni: ClangArgs.Jni by lazy {
+        ClangArgs.Jni(configurables)
+    }
+
+    val linker: LinkerFlags by lazy {
        linker(configurables)
    }
 }