Add DESTROY_RUNTIME_ON_SHUTDOWN_CHECKED

Author: projedi

backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/K2Native.kt

@@ -250,6 +250,15 @@ class K2Native : CLICompiler<K2NativeCompilerArguments>() {
                 put(DISABLE_FAKE_OVERRIDE_VALIDATOR, arguments.disableFakeOverrideValidator)
                 putIfNotNull(PRE_LINK_CACHES, parsePreLinkCachesValue(configuration, arguments.preLinkCaches))
                 putIfNotNull(OVERRIDE_KONAN_PROPERTIES, parseOverrideKonanProperties(arguments, configuration))
+                put(DESTROY_RUNTIME_MODE, when (arguments.destroyRuntimeMode) {
+                    "legacy" -> DestroyRuntimeMode.LEGACY
+                    "on-shutdown" -> DestroyRuntimeMode.ON_SHUTDOWN
+                    "on-shutdown-checked" -> DestroyRuntimeMode.ON_SHUTDOWN_CHECKED
+                    else -> {
+                        configuration.report(ERROR, "Unsupported destroy runtime mode ${arguments.destroyRuntimeMode}")
+                        DestroyRuntimeMode.ON_SHUTDOWN
+                    }
+                })
             }
         }
     }

backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/K2NativeCompilerArguments.kt

@@ -285,6 +285,9 @@ class K2NativeCompilerArguments : CommonCompilerArguments() {
     )
     var overrideKonanProperties: Array<String>? = null
 
+    @Argument(value="-Xdestroy-runtime-mode", valueDescription = "<mode>", description = "When to destroy runtime. 'legacy', 'on-shutdown' and 'on-shutdown-checked' are currently supported. NOTE: 'legacy' mode is deprecated and will be removed.")
+    var destroyRuntimeMode: String? = "on-shutdown"
+
     override fun configureAnalysisFlags(collector: MessageCollector): MutableMap<AnalysisFlag<*>, Any> =
             super.configureAnalysisFlags(collector).also {
                 val useExperimental = it[AnalysisFlags.useExperimental] as List<*>

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/DestroyRuntimeMode.kt

@@ -0,0 +1,12 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+package org.jetbrains.kotlin.backend.konan
+
+// Must match DestroyRuntimeMode in Runtime.h
+enum class DestroyRuntimeMode(val value: Int) {
+    LEGACY(0),
+    ON_SHUTDOWN(1),
+    ON_SHUTDOWN_CHECKED(2)
+}

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfig.kt

@@ -45,6 +45,7 @@ class KonanConfig(val project: Project, val configuration: CompilerConfiguration
             ?: target.family.isAppleFamily // Default is true for Apple targets.
 
     val memoryModel: MemoryModel get() = configuration.get(KonanConfigKeys.MEMORY_MODEL)!!
+    val destroyRuntimeMode: DestroyRuntimeMode get() = configuration.get(KonanConfigKeys.DESTROY_RUNTIME_MODE)!!
 
     val needCompilerVerification: Boolean
         get() = configuration.get(KonanConfigKeys.VERIFY_COMPILER) ?:
@@ -128,6 +129,10 @@ class KonanConfig(val project: Project, val configuration: CompilerConfiguration
                     configuration.report(CompilerMessageSeverity.STRONG_WARNING,
                             "Experimental memory model requires threads, which are not supported on target ${target.name}. Used strict memory model.")
                     MemoryModel.STRICT
+                } else if (destroyRuntimeMode == DestroyRuntimeMode.LEGACY) {
+                    configuration.report(CompilerMessageSeverity.STRONG_WARNING,
+                            "Experimental memory model is incompatible with 'legacy' destroy runtime mode. Used strict memory model.")
+                    MemoryModel.STRICT
                 } else {
                     MemoryModel.EXPERIMENTAL
                 }

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfigurationKeys.kt

@@ -144,6 +144,8 @@ class KonanConfigKeys {
                 = CompilerConfigurationKey.create("perform compiler caches pre-link")
         val OVERRIDE_KONAN_PROPERTIES: CompilerConfigurationKey<Map<String, String>>
                 = CompilerConfigurationKey.create("override konan.properties values")
+        val DESTROY_RUNTIME_MODE: CompilerConfigurationKey<DestroyRuntimeMode>
+                = CompilerConfigurationKey.create("when to destroy runtime")
     }
 }
 

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt

@@ -362,7 +362,7 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
             codegen.objCDataGenerator?.finishModule()
 
             context.coverage.writeRegionInfo()
-            appendDebugSelector()
+            appendCompilerGlobals()
             appendLlvmUsed("llvm.used", context.llvm.usedFunctions + context.llvm.usedGlobals)
             appendLlvmUsed("llvm.compiler.used", context.llvm.compilerUsedGlobals)
             if (context.isNativeLibrary) {
@@ -2378,13 +2378,19 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
         LLVMSetSection(llvmUsedGlobal.llvmGlobal, "llvm.metadata")
     }
 
-    private fun appendDebugSelector() {
-        if (!context.producedLlvmModuleContainsStdlib) return
-        val llvmDebugSelector =
-                context.llvm.staticData.placeGlobal("KonanNeedDebugInfo",
-                        Int32(if (context.shouldContainDebugInfo()) 1 else 0))
-        llvmDebugSelector.setConstant(true)
-        llvmDebugSelector.setLinkage(LLVMLinkage.LLVMExternalLinkage)
+    private fun appendGlobal(name: String, value: ConstValue, isStrongSymbol: Boolean) {
+        val constant = context.llvm.staticData.placeGlobal(name, value)
+        constant.setConstant(true)
+        constant.setLinkage(if (isStrongSymbol) LLVMLinkage.LLVMExternalLinkage else LLVMLinkage.LLVMExternalWeakLinkage)
+    }
+
+    private fun appendCompilerGlobals() {
+        if (context.producedLlvmModuleContainsStdlib) {
+            appendGlobal("KonanNeedDebugInfo", Int32(if (context.shouldContainDebugInfo()) 1 else 0), true)
+        }
+        val isStrongSymbol = context.config.produce.isFinalBinary
+        println("Setting Kotlin_destroyRuntimeMode strong=$isStrongSymbol value=${context.config.destroyRuntimeMode.value}")
+        appendGlobal("Kotlin_destroyRuntimeMode", Int32(context.config.destroyRuntimeMode.value), isStrongSymbol)
     }
 
     //-------------------------------------------------------------------------//

backend.native/tests/build.gradle

@@ -4351,9 +4351,20 @@ dynamicTest("interop_cleaners_leak") {
     flags = ['-Xopt-in=kotlin.native.internal.InternalForKotlinNative']
 }
 
+dynamicTest("interop_migrating_main_thread_legacy") {
+    // TODO: Fix it.
+    disabled = (project.testTarget != null && project.testTarget != project.hostName)
+    source = "interop/migrating_main_thread/lib.kt"
+    flags = ['-Xdestroy-runtime-mode=legacy']
+    clangFlags = ['-DIS_LEGACY']
+    cSource = "$projectDir/interop/migrating_main_thread/main.cpp"
+    clangTool = "clang++"
+}
+
 dynamicTest("interop_migrating_main_thread") {
     disabled = (project.target.name != project.hostName)
     source = "interop/migrating_main_thread/lib.kt"
+    flags = ['-Xdestroy-runtime-mode=on-shutdown']
     cSource = "$projectDir/interop/migrating_main_thread/main.cpp"
     clangTool = "clang++"
 }
@@ -4364,7 +4375,7 @@ dynamicTest("interop_memory_leaks") {
     source = "interop/memory_leaks/lib.kt"
     cSource = "$projectDir/interop/memory_leaks/main.cpp"
     clangTool = "clang++"
-    flags = ['-g']
+    flags = ['-g', '-Xdestroy-runtime-mode=legacy'] // Runtime cannot be destroyed with interop with on-shutdown.
     expectedExitStatusChecker = { it != 0 }
     outputChecker = { s -> s.contains("Memory leaks detected, 1 objects leaked!") }
 }

backend.native/tests/interop/migrating_main_thread/main.cpp

@@ -8,17 +8,27 @@
 #include <cassert>
 #include <thread>
 
+constexpr int kInitialValue = 0;
+constexpr int kNewValue = 0;
+
+#if defined(IS_LEGACY)
+// Globals were reinitialized.
+constexpr int kResultValue = kInitialValue;
+#else
+// Globals were kept.
+constexpr int kResultValue = kNewValue;
+#endif
+
 int main() {
     std::thread main1([]() {
-        assert(testlib_symbols()->kotlin.root.readFromA() == 0);
-        testlib_symbols()->kotlin.root.writeToA(1);
-        assert(testlib_symbols()->kotlin.root.readFromA() == 1);
+        assert(testlib_symbols()->kotlin.root.readFromA() == kInitialValue);
+        testlib_symbols()->kotlin.root.writeToA(kNewValue);
+        assert(testlib_symbols()->kotlin.root.readFromA() == kNewValue);
     });
     main1.join();
 
     std::thread main2([]() {
-        // Globals were reinitialized.
-        assert(testlib_symbols()->kotlin.root.readFromA() == 0);
+        assert(testlib_symbols()->kotlin.root.readFromA() == kResultValue);
     });
     main2.join();
 

backend.native/tests/interop/objc/smoke.kt

@@ -10,6 +10,8 @@ import kotlin.native.ref.*
 import kotlin.test.*
 
 fun main(args: Array<String>) {
+    // Test relies on full deinitialization at shutdown.
+    kotlin.native.Platform.forceCheckedShutdown = true
     autoreleasepool {
         run()
     }

build-tools/src/main/kotlin/org/jetbrains/kotlin/KotlinNativeTest.kt

@@ -418,8 +418,12 @@ open class KonanDynamicTest : KonanStandaloneTest() {
     @Input
     lateinit var cSource: String
 
+    @Input
     var clangTool = "clang"
 
+    @Input
+    var clangFlags: List<String> = listOf()
+
     // Replace testlib_api.h and all occurrences of the testlib with the actual name of the test
     private fun processCSource(): String {
         val sourceFile = File(cSource)
@@ -452,7 +456,7 @@ open class KonanDynamicTest : KonanStandaloneTest() {
                     "-c",
                     "-o", "$executable.o",
                     "-I", artifactsDir
-            )
+            ) + clangFlags
             it.standardOutput = log
             it.errorOutput = log
             it.isIgnoreExitValue = true
@@ -481,4 +485,4 @@ open class KonanDynamicTest : KonanStandaloneTest() {
             it.execute()
         }
     }
-}
+}