[K/N] Move all knowledge about CompileToBitcode to the plugin.

Merge-request: KT-MR-6215 Merged-by: Alexander Shabalin <Alexander.Shabalin@jetbrains.com>
2022-05-12 12:20:31 +00:00
parent 2796d21ec6
commit d77041aad0
7 changed files with 202 additions and 373 deletions
@@ -18,7 +18,6 @@ import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.OutputFile
 import org.gradle.api.tasks.TaskAction
 import org.gradle.kotlin.dsl.getByType
-import org.jetbrains.kotlin.bitcode.CompileToBitcode
 import java.io.FileReader
 import java.io.FileWriter

@@ -111,28 +110,3 @@ fun mergeCompilationDatabases(project: Project, name: String, paths: List<String
        inputFiles.addAll(subtasks.map { it.outputFile })
    }
 }
-
-/**
- * Get all [CompileToBitcode] tasks in the project, group them by target, and generate
- * compilation database for each target. Tasks will be named <target>[name]. Databases
- * will be placed in a build dir in <target>/compile_commands.json
- */
-fun createCompilationDatabasesFromCompileToBitcodeTasks(project: Project, name: String) {
-    val compileTasks = project.tasks.withType(CompileToBitcode::class.java).toList()
-    val compdbTasks = compileTasks.groupBy({ task -> task.target }) { task ->
-        project.tasks.create("${task.name}_CompilationDatabase",
-                GenerateCompilationDatabase::class.java,
-                task.target,
-                task.inputFiles,
-                task.executable,
-                task.compilerFlags,
-                task.objDir)
-    }
-    for ((target, tasks) in compdbTasks) {
-        project.tasks.create("${target}${name}", MergeCompilationDatabases::class.java) {
-            dependsOn(tasks)
-            inputFiles.addAll(tasks.map { it.outputFile })
-            outputFile = File(File(project.buildDir, target), "compile_commands.json")
-        }
-    }
-}
@@ -212,9 +212,12 @@ abstract class CompileToBitcode @Inject constructor(
            }
        }

+    @Input
+    var outputName = "${folderName}.bc"
+
    @get:OutputFile
    val outFile: File
-        get() = File(targetDir, "${folderName}.bc")
+        get() = File(targetDir, outputName)

    @get:Inject
    abstract val workerExecutor: WorkerExecutor
@@ -7,31 +7,30 @@ package org.jetbrains.kotlin.bitcode

 import org.gradle.api.Plugin
 import org.gradle.api.Project
+import org.gradle.api.Task
 import org.gradle.api.plugins.BasePlugin
-import org.jetbrains.kotlin.createCompilationDatabasesFromCompileToBitcodeTasks
+import org.jetbrains.kotlin.GenerateCompilationDatabase
+import org.jetbrains.kotlin.MergeCompilationDatabases
 import org.jetbrains.kotlin.konan.target.PlatformManager
 import org.jetbrains.kotlin.konan.target.SanitizerKind
 import org.jetbrains.kotlin.konan.target.supportedSanitizers
+import org.jetbrains.kotlin.testing.native.CompileNativeTest
+import org.jetbrains.kotlin.testing.native.GoogleTestExtension
+import org.jetbrains.kotlin.testing.native.RunNativeTest
+import org.jetbrains.kotlin.testing.native.RuntimeTestingPlugin
 import java.io.File
 import javax.inject.Inject

 /**
 * A plugin creating extensions to compile
 */
-open class CompileToBitcodePlugin: Plugin<Project> {
-    override fun apply(target: Project) = with(target) {
-        extensions.create(EXTENSION_NAME, CompileToBitcodeExtension::class.java, target)
-
-        afterEvaluate {
-            // TODO: Support providers (https://docs.gradle.org/current/userguide/lazy_configuration.html)
-            //       in database tasks and create them along with corresponding compile tasks (not in afterEvaluate).
-            createCompilationDatabasesFromCompileToBitcodeTasks(project, COMPILATION_DATABASE_TASK_NAME)
-        }
+open class CompileToBitcodePlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        target.extensions.create(EXTENSION_NAME, CompileToBitcodeExtension::class.java, target)
    }

    companion object {
        const val EXTENSION_NAME = "bitcode"
-        const val COMPILATION_DATABASE_TASK_NAME = "CompilationDatabase"
    }
 }

@@ -41,22 +40,48 @@ open class CompileToBitcodeExtension @Inject constructor(val project: Project) {
        provider { (rootProject.project(":kotlin-native").property("targetList") as? List<*>)?.filterIsInstance<String>() ?: emptyList() } // TODO: Can we make it better?
    }

-    fun create(
-            name: String,
-            srcRoot: File = project.file("src/$name"),
-            outputGroup: String = "main",
-            configurationBlock: CompileToBitcode.() -> Unit = {}
-    ) {
+    private val allMainModulesTasks by lazy {
+        val name = project.name.capitalized
+        targetList.get().associateBy(keySelector = { it }, valueTransform = {
+            project.tasks.register("${it}$name")
+        })
+    }
+
+    private val allTestsTasks by lazy {
+        val name = project.name.capitalized
+        targetList.get().associateBy(keySelector = { it }, valueTransform = {
+            project.tasks.register("${it}${name}Tests")
+        })
+    }
+
+    private val compdbTasks by lazy {
+        targetList.get().associateBy(keySelector = { it }, valueTransform = {
+            val task = project.tasks.register("${it}${COMPILATION_DATABASE_TASK_NAME}", MergeCompilationDatabases::class.java)
+            task.configure {
+                outputFile = File(File(project.buildDir, it), "compile_commands.json")
+            }
+            task
+        })
+    }
+
+    private fun addToCompdb(compileTask: CompileToBitcode) {
+        val task = project.tasks.create("${compileTask.name}_CompilationDatabase", GenerateCompilationDatabase::class.java, compileTask.target, compileTask.inputFiles, compileTask.executable, compileTask.compilerFlags, compileTask.objDir)
+        val compdbTask = compdbTasks[compileTask.target]!!
+        compdbTask.configure {
+            dependsOn(task)
+            inputFiles.add(task.outputFile)
+        }
+    }
+
+    fun module(name: String, srcRoot: File = project.file("src/$name"), outputGroup: String = "main", configurationBlock: CompileToBitcode.() -> Unit = {}) {
        targetList.get().forEach { targetName ->
            val platformManager = project.rootProject.project(":kotlin-native").findProperty("platformManager") as PlatformManager
            val target = platformManager.targetByName(targetName)
            val sanitizers: List<SanitizerKind?> = target.supportedSanitizers() + listOf(null)
+            val allMainModulesTask = allMainModulesTasks[targetName]!!
            sanitizers.forEach { sanitizer ->
-                project.tasks.register(
-                        "${targetName}${name.snakeCaseToCamelCase().replaceFirstChar { it.uppercase() }}${suffixForSanitizer(sanitizer)}",
-                        CompileToBitcode::class.java,
-                        name, targetName, outputGroup
-                ).configure {
+                val taskName = fullTaskName(name, targetName, sanitizer)
+                val task = project.tasks.create(taskName, CompileToBitcode::class.java, name, targetName, outputGroup).apply {
                    srcDirs = project.files(srcRoot.resolve("cpp"))
                    headersDirs = srcDirs + project.files(srcRoot.resolve("headers"))

@@ -71,17 +96,120 @@ open class CompileToBitcodeExtension @Inject constructor(val project: Project) {
                    dependsOn(":kotlin-native:dependencies:update")
                    configurationBlock()
                }
+                addToCompdb(task)
+                if (outputGroup == "main" && sanitizer == null) {
+                    allMainModulesTask.configure {
+                        dependsOn(taskName)
+                    }
+                }
+            }
+        }
+    }
+
+    private fun createTestTask(
+            project: Project,
+            testName: String,
+            testedTaskNames: List<String>,
+            sanitizer: SanitizerKind?,
+    ): Task {
+        val platformManager = project.project(":kotlin-native").findProperty("platformManager") as PlatformManager
+        val googleTestExtension = project.extensions.getByName(RuntimeTestingPlugin.GOOGLE_TEST_EXTENSION_NAME) as GoogleTestExtension
+        val testedTasks = testedTaskNames.map {
+            project.tasks.getByName(it) as CompileToBitcode
+        }
+        val target = testedTasks.map {
+            it.target
+        }.distinct().single()
+        val konanTarget = platformManager.targetByName(target)
+        val compileToBitcodeTasks = testedTasks.mapNotNull {
+            val name = "${it.name}TestBitcode"
+            val task = project.tasks.findByName(name) as? CompileToBitcode
+                    ?: project.tasks.create(name, CompileToBitcode::class.java, "${it.folderName}Tests", target, "test").apply {
+                        srcDirs = it.srcDirs
+                        headersDirs = it.headersDirs + googleTestExtension.headersDirs
+
+                        this.sanitizer = sanitizer
+                        excludeFiles = emptyList()
+                        includeFiles = listOf("**/*Test.cpp", "**/*TestSupport.cpp", "**/*Test.mm", "**/*TestSupport.mm")
+                        dependsOn(":kotlin-native:dependencies:update")
+                        dependsOn("downloadGoogleTest")
+                        compilerArgs.addAll(it.compilerArgs)
+
+                        addToCompdb(this)
+                    }
+            if (task.inputFiles.count() == 0) null
+            else task
+        }
+        // TODO: Consider using sanitized versions.
+        val testFrameworkTasks = listOf(project.tasks.getByName(fullTaskName("googletest", target, null)) as CompileToBitcode, project.tasks.getByName(fullTaskName("googlemock", target, null)) as CompileToBitcode)
+
+        val testSupportTask = project.tasks.getByName(fullTaskName("test_support", target, sanitizer)) as CompileToBitcode
+
+        val mimallocEnabled = testedTaskNames.any { it.contains("mimalloc", ignoreCase = true) }
+        val compileTask = project.tasks.create(
+                "${testName}Compile",
+                CompileNativeTest::class.java,
+                testName,
+                konanTarget,
+                testSupportTask.outFile,
+                platformManager,
+                mimallocEnabled,
+        ).apply {
+            val tasksToLink = (compileToBitcodeTasks + testedTasks + testFrameworkTasks)
+            this.sanitizer = sanitizer
+            this.inputFiles.setFrom(tasksToLink.map { it.outFile })
+            dependsOn(testSupportTask)
+            dependsOn(tasksToLink)
+        }
+
+        val runTask = project.tasks.create(
+                testName,
+                RunNativeTest::class.java,
+                testName,
+                compileTask.outputFile,
+        ).apply {
+            this.sanitizer = sanitizer
+            dependsOn(compileTask)
+        }
+
+        return runTask
+    }
+
+    fun testsGroup(
+            testTaskName: String,
+            testedTaskNames: List<String>,
+    ) {
+        val platformManager = project.rootProject.project(":kotlin-native").findProperty("platformManager") as PlatformManager
+        targetList.get().forEach { targetName ->
+            val target = platformManager.targetByName(targetName)
+            val sanitizers: List<SanitizerKind?> = target.supportedSanitizers() + listOf(null)
+            val allTestsTask = allTestsTasks[targetName]!!
+            sanitizers.forEach { sanitizer ->
+                val name = fullTaskName(testTaskName, targetName, sanitizer)
+                val testedNames = testedTaskNames.map {
+                    fullTaskName(it, targetName, sanitizer)
+                }
+                val task = createTestTask(project, name, testedNames, sanitizer)
+                allTestsTask.configure {
+                    dependsOn(task)
+                }
            }
        }
    }

    companion object {

-        private fun String.snakeCaseToCamelCase() =
-                split('_').joinToString(separator = "") { word -> word.replaceFirstChar { it.uppercase() } }
+        private const val COMPILATION_DATABASE_TASK_NAME = "CompilationDatabase"

-        fun suffixForSanitizer(sanitizer: SanitizerKind?) =
-            when (sanitizer) {
+        private val String.capitalized: String
+            get() = replaceFirstChar { it.uppercase() }
+
+        private fun String.snakeCaseToUpperCamelCase() = split('_').joinToString(separator = "") { it.capitalized }
+
+        private fun fullTaskName(name: String, targetName: String, sanitizer: SanitizerKind?) = "${targetName}${name.snakeCaseToUpperCamelCase()}${sanitizer.suffix}"
+
+        private val SanitizerKind?.suffix
+            get() = when (this) {
                null -> ""
                SanitizerKind.ADDRESS -> "_ASAN"
                SanitizerKind.THREAD -> "_TSAN"
@@ -12,14 +12,11 @@ import org.gradle.api.*
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.tasks.*
 import org.gradle.api.model.ObjectFactory
-import org.gradle.kotlin.dsl.getByType
 import org.gradle.process.ExecOperations
 import org.gradle.workers.WorkAction
 import org.gradle.workers.WorkParameters
 import org.gradle.workers.WorkerExecutor
 import org.jetbrains.kotlin.ExecClang
-import org.jetbrains.kotlin.bitcode.CompileToBitcode
-import org.jetbrains.kotlin.bitcode.CompileToBitcodeExtension
 import org.jetbrains.kotlin.konan.target.*
 import java.io.OutputStream

@@ -81,15 +78,17 @@ abstract class CompileNativeTestJob : WorkAction<CompileNativeTestParameters> {
            val execClang = ExecClang.create(objects, platformManager, llvmDir)
            val target = platformManager.targetByName(targetName)

+            val clangFlags = buildClangFlags(platformManager.platform(target).configurables)
+
            if (target.family.isAppleFamily) {
                execClang.execToolchainClang(target) {
                    executable = "clang++"
-                    this.args = compilerArgs + listOf(llvmLinkOutputFile.absolutePath, "-o", compilerOutputFile.absolutePath)
+                    this.args = clangFlags + compilerArgs + listOf(llvmLinkOutputFile.absolutePath, "-o", compilerOutputFile.absolutePath)
                }
            } else {
                execClang.execBareClang {
                    executable = "clang++"
-                    this.args = compilerArgs + listOf(llvmLinkOutputFile.absolutePath, "-o", compilerOutputFile.absolutePath)
+                    this.args = clangFlags + compilerArgs + listOf(llvmLinkOutputFile.absolutePath, "-o", compilerOutputFile.absolutePath)
                }
            }
        }
@@ -201,7 +200,7 @@ abstract class CompileNativeTest @Inject constructor(

            it.konanHome = project.project(":kotlin-native").projectDir
            it.llvmDir = project.file(project.findProperty("llvmDir")!!)
-            it.isInfoEnabled = logger.isInfoEnabled()
+            it.isInfoEnabled = logger.isInfoEnabled
        }

        workQueue.submit(CompileNativeTestJob::class.java, parameters)
@@ -274,104 +273,4 @@ private fun buildClangFlags(configurables: Configurables): List<String> = mutabl
        configurables.targetTriple
    }
    addAll(listOf("-triple", targetTriple.toString()))
-}.toList()
-
-private fun createTestTask(
-        project: Project,
-        testName: String,
-        testedTaskNames: List<String>,
-        sanitizer: SanitizerKind?,
-        configureCompileToBitcode: CompileToBitcode.() -> Unit = {}
-): Task {
-    val platformManager = project.project(":kotlin-native").findProperty("platformManager") as PlatformManager
-    val googleTestExtension = project.extensions.getByName(RuntimeTestingPlugin.GOOGLE_TEST_EXTENSION_NAME) as GoogleTestExtension
-    val testedTasks = testedTaskNames.map {
-        project.tasks.getByName(it) as CompileToBitcode
-    }
-    val target = testedTasks.map {
-        it.target
-    }.distinct().single()
-    val konanTarget = platformManager.targetByName(target)
-    val compileToBitcodeTasks = testedTasks.mapNotNull {
-        val name = "${it.name}TestBitcode"
-        val task = project.tasks.findByName(name) as? CompileToBitcode ?:
-            project.tasks.create(name,
-                    CompileToBitcode::class.java,
-                    "${it.folderName}Tests",
-                    target, "test"
-                    ).apply {
-                srcDirs = it.srcDirs
-                headersDirs = it.headersDirs + googleTestExtension.headersDirs
-
-                this.sanitizer = sanitizer
-                excludeFiles = emptyList()
-                includeFiles = listOf("**/*Test.cpp", "**/*TestSupport.cpp", "**/*Test.mm", "**/*TestSupport.mm")
-                dependsOn(it)
-                dependsOn("downloadGoogleTest")
-                compilerArgs.addAll(it.compilerArgs)
-                this.configureCompileToBitcode()
-            }
-        if (task.inputFiles.count() == 0)
-            null
-        else
-            task
-    }
-    // TODO: Consider using sanitized versions.
-    val testFrameworkTasks = listOf(
-        project.tasks.getByName("${target}Googletest") as CompileToBitcode,
-        project.tasks.getByName("${target}Googlemock") as CompileToBitcode
-    )
-
-    val testSupportTask = project.tasks.getByName("${target}TestSupport${CompileToBitcodeExtension.suffixForSanitizer(sanitizer)}") as CompileToBitcode
-
-    val mimallocEnabled = testedTaskNames.any { it.contains("mimalloc", ignoreCase = true) }
-    val compileTask = project.tasks.create(
-            "${testName}Compile",
-            CompileNativeTest::class.java,
-            testName,
-            konanTarget,
-            testSupportTask.outFile,
-            platformManager,
-            mimallocEnabled,
-    ).apply {
-        val tasksToLink = (compileToBitcodeTasks + testedTasks + testFrameworkTasks)
-        this.sanitizer = sanitizer
-        this.inputFiles.setFrom(tasksToLink.map { it.outFile })
-        this.clangArgs.addAll(buildClangFlags(platformManager.platform(konanTarget).configurables))
-        dependsOn(testSupportTask)
-        dependsOn(tasksToLink)
-    }
-
-    val runTask = project.tasks.create(
-        testName,
-        RunNativeTest::class.java,
-        testName,
-        compileTask.outputFile,
-    ).apply {
-        this.sanitizer = sanitizer
-        dependsOn(compileTask)
-    }
-
-    return runTask
-}
-
-// TODO: These tests should be created by `CompileToBitcodeExtension`
-fun createTestTasks(
-        project: Project,
-        targetName: String,
-        testTaskName: String,
-        testedTaskNames: List<String>,
-        configureCompileToBitcode: CompileToBitcode.() -> Unit = {}
-): List<Task> {
-    val platformManager = project.rootProject.project(":kotlin-native").findProperty("platformManager") as PlatformManager
-    val target = platformManager.targetByName(targetName)
-    val sanitizers: List<SanitizerKind?> = target.supportedSanitizers() + listOf(null)
-    return sanitizers.map { sanitizer ->
-        val suffix = CompileToBitcodeExtension.suffixForSanitizer(sanitizer)
-        val name = testTaskName + suffix
-        val testedNames = testedTaskNames.map {
-            it + suffix
-        }
-        createTestTask(project, name, testedNames, sanitizer, configureCompileToBitcode)
-    }
-}
+}.toList()
@@ -54,7 +54,7 @@ open class RuntimeTestingPlugin : Plugin<Project> {
            val bitcodeExtension =
                    project.extensions.getByName(CompileToBitcodePlugin.EXTENSION_NAME) as CompileToBitcodeExtension

-            bitcodeExtension.create("googletest", outputGroup = "test") {
+            bitcodeExtension.module("googletest", outputGroup = "test") {
                srcDirs = project.files(
                        googleTestRoot.resolve("googletest/src")
                )
@@ -69,7 +69,7 @@ open class RuntimeTestingPlugin : Plugin<Project> {
                dependsOn(dependencies)
            }

-            bitcodeExtension.create("googlemock", outputGroup = "test") {
+            bitcodeExtension.module("googlemock", outputGroup = "test") {
                srcDirs = project.files(
                        googleTestRoot.resolve("googlemock/src")
                )
@@ -8,19 +8,14 @@ plugins {
 }

 bitcode {
-    create("files"){
-        dependsOn(":kotlin-native:dependencies:update")
-    }
-    create("env"){
-        dependsOn(":kotlin-native:dependencies:update")
-    }
+    module("files")
+    module("env")
 }

 val hostName: String by project

 val build by tasks.registering {
-    dependsOn("${hostName}Files")
-    dependsOn("${hostName}Env")
+    dependsOn("${hostName}Common")
 }

 val clean by tasks.registering {
@@ -3,7 +3,6 @@
 * that can be found in the LICENSE file.
 */
 import org.jetbrains.kotlin.*
-import org.jetbrains.kotlin.testing.native.*
 import org.jetbrains.kotlin.bitcode.CompileToBitcode
 import org.jetbrains.kotlin.gradle.plugin.konan.tasks.KonanCacheTask
 import org.jetbrains.kotlin.konan.properties.loadProperties
@@ -41,33 +40,13 @@ val hostName: String by project
 val targetList: List<String> by project

 bitcode {
-    create("runtime", file("src/main")) {
-        dependsOn(
-            ":kotlin-native:dependencies:update",
-            "${target}StdAlloc",
-            "${target}OptAlloc",
-            "${target}Mimalloc",
-            "${target}Libbacktrace",
-            "${target}Launcher",
-            "${target}Debug",
-            "${target}SourceInfoCoreSymbolication",
-            "${target}SourceInfoLibbacktrace",
-            "${target}Strict",
-            "${target}Relaxed",
-            "${target}ProfileRuntime",
-            "${target}Objc",
-            "${target}ExceptionsSupport",
-            "${target}LegacyMemoryManager",
-            "${target}ExperimentalMemoryManager",
-            "${target}CommonGc",
-            "${target}SameThreadMsGc",
-            "${target}ConcurrentMsGc",
-            "${target}NoopGc"
-        )
+    module("main") {
        includeRuntime()
+
+        outputName = "runtime.bc"
    }

-    create("mimalloc") {
+    module("mimalloc") {
        val srcRoot = file("src/mimalloc")
        language = CompileToBitcode.Language.C
        includeFiles = listOf("**/*.c")
@@ -82,7 +61,7 @@ bitcode {
        onlyIf { targetSupportsMimallocAllocator(target) }
    }

-    create("libbacktrace") {
+    module("libbacktrace") {
        val srcRoot = file("src/libbacktrace")
        val targetInfo = HostManager().targetByName(target)
        language = CompileToBitcode.Language.C
@@ -122,231 +101,102 @@ bitcode {
    }


-    create("launcher") {
+    module("launcher") {
        includeRuntime()
    }

-    create("debug") {
+    module("debug") {
        includeRuntime()
    }

-    create("std_alloc") {
+    module("std_alloc") {
        includeRuntime()
    }

-    create("opt_alloc") {
+    module("opt_alloc") {
        includeRuntime()
    }

-    create("exceptionsSupport", file("src/exceptions_support")) {
+    module("exceptionsSupport", file("src/exceptions_support")) {
        includeRuntime()
    }

-    create("source_info_core_symbolication", file("src/source_info/core_symbolication")) {
+    module("source_info_core_symbolication", file("src/source_info/core_symbolication")) {
        includeRuntime()
        onlyIf { targetSupportsCoreSymbolication(target) }
    }
-    create("source_info_libbacktrace", file("src/source_info/libbacktrace")) {
+    module("source_info_libbacktrace", file("src/source_info/libbacktrace")) {
        includeRuntime()
        headersDirs += files("src/libbacktrace/c/include")
        onlyIf { targetSupportsLibBacktrace(target) }
    }

-    create("strict") {
+    module("strict") {
        includeRuntime()
    }

-    create("relaxed") {
+    module("relaxed") {
        includeRuntime()
    }

-    create("profileRuntime", file("src/profile_runtime"))
+    module("profileRuntime", file("src/profile_runtime"))

-    create("objc") {
+    module("objc") {
        includeRuntime()
    }

-    create("test_support", outputGroup = "test") {
+    module("test_support", outputGroup = "test") {
        includeRuntime()
        dependsOn("downloadGoogleTest")
        headersDirs += googletest.headersDirs
    }

-    create("legacy_memory_manager", file("src/legacymm")) {
+    module("legacy_memory_manager", file("src/legacymm")) {
        includeRuntime()
    }

-    create("experimental_memory_manager", file("src/mm")) {
+    module("experimental_memory_manager", file("src/mm")) {
        headersDirs += files("src/gc/common/cpp")
        includeRuntime()
    }

-    create("common_gc", file("src/gc/common")) {
+    module("common_gc", file("src/gc/common")) {
        headersDirs += files("src/mm/cpp")
        includeRuntime()
    }

-    create("noop_gc", file("src/gc/noop")) {
+    module("noop_gc", file("src/gc/noop")) {
        headersDirs += files("src/gc/noop/cpp", "src/gc/common/cpp", "src/mm/cpp")
        includeRuntime()
    }

-    create("same_thread_ms_gc", file("src/gc/stms")) {
+    module("same_thread_ms_gc", file("src/gc/stms")) {
        headersDirs += files("src/gc/stms/cpp", "src/gc/common/cpp", "src/mm/cpp")
        includeRuntime()
    }

-    create("concurrent_ms_gc", file("src/gc/cms")) {
+    module("concurrent_ms_gc", file("src/gc/cms")) {
        headersDirs += files("src/gc/cms/cpp", "src/gc/common/cpp", "src/mm/cpp")
        includeRuntime()

        onlyIf { targetSupportsThreads(target) }
    }
-}

-targetList.forEach { targetName ->
-    val allTests = mutableListOf<Task>()
+    testsGroup("std_alloc_runtime_tests", listOf("main", "legacy_memory_manager", "strict", "std_alloc", "objc"))

-    allTests.addAll(createTestTasks(
-            project,
-            targetName,
-            "${targetName}StdAllocRuntimeTests",
-            listOf(
-                "${targetName}Runtime",
-                "${targetName}LegacyMemoryManager",
-                "${targetName}Strict",
-                "${targetName}StdAlloc",
-                "${targetName}Objc"
-            )
-    ) {
-        includeRuntime()
-    })
+    testsGroup("mimalloc_runtime_tests", listOf("main", "legacy_memory_manager", "strict", "mimalloc", "opt_alloc", "objc"))

-    allTests.addAll(createTestTasks(
-            project,
-            targetName,
-            "${targetName}MimallocRuntimeTests",
-            listOf(
-                "${targetName}Runtime",
-                "${targetName}LegacyMemoryManager",
-                "${targetName}Strict",
-                "${targetName}Mimalloc",
-                "${targetName}OptAlloc",
-                "${targetName}Objc"
-            )
-    ) {
-        includeRuntime()
-    })
+    testsGroup("experimentalMM_mimalloc_runtime_tests", listOf("main", "experimental_memory_manager", "common_gc", "same_thread_ms_gc", "mimalloc", "opt_alloc", "objc"))

-    allTests.addAll(createTestTasks(
-            project,
-            targetName,
-            "${targetName}ExperimentalMMMimallocRuntimeTests",
-            listOf(
-                "${targetName}Runtime",
-                "${targetName}ExperimentalMemoryManager",
-                "${targetName}CommonGc",
-                "${targetName}SameThreadMsGc",
-                "${targetName}Mimalloc",
-                "${targetName}OptAlloc",
-                "${targetName}Objc"
-            )
-    ) {
-        headersDirs += files("src/gc/stms/cpp", "src/gc/common/cpp", "src/mm/cpp")
-        includeRuntime()
-    })
+    testsGroup("experimentalMM_std_alloc_runtime_tests", listOf("main", "experimental_memory_manager", "common_gc", "same_thread_ms_gc", "std_alloc", "objc"))

-    allTests.addAll(createTestTasks(
-            project,
-            targetName,
-            "${targetName}ExperimentalMMStdAllocRuntimeTests",
-            listOf(
-                "${targetName}Runtime",
-                "${targetName}ExperimentalMemoryManager",
-                "${targetName}CommonGc",
-                "${targetName}SameThreadMsGc",
-                "${targetName}StdAlloc",
-                "${targetName}Objc"
-            )
-    ) {
-        headersDirs += files("src/gc/stms/cpp", "src/gc/common/cpp", "src/mm/cpp")
-        includeRuntime()
-    })
+    testsGroup("experimentalMM_cms_mimalloc_runtime_tests", listOf("main", "experimental_memory_manager", "common_gc", "concurrent_ms_gc", "mimalloc", "opt_alloc", "objc"))

-    allTests.addAll(createTestTasks(
-            project,
-            targetName,
-            "${targetName}ExperimentalMMCmsMimallocRuntimeTests",
-            listOf(
-                    "${targetName}Runtime",
-                    "${targetName}ExperimentalMemoryManager",
-                    "${targetName}CommonGc",
-                    "${targetName}ConcurrentMsGc",
-                    "${targetName}Mimalloc",
-                    "${targetName}OptAlloc",
-                    "${targetName}Objc"
-            )
-    ) {
-        headersDirs += files("src/gc/cms/cpp", "src/gc/common/cpp", "src/mm/cpp")
-        includeRuntime()
-    })
+    testsGroup("experimentalMM_cms_std_alloc_runtime_tests", listOf("main", "experimental_memory_manager", "common_gc", "concurrent_ms_gc", "std_alloc", "objc"))

-    allTests.addAll(createTestTasks(
-            project,
-            targetName,
-            "${targetName}ExperimentalMMCmsStdAllocRuntimeTests",
-            listOf(
-                    "${targetName}Runtime",
-                    "${targetName}ExperimentalMemoryManager",
-                    "${targetName}CommonGc",
-                    "${targetName}ConcurrentMsGc",
-                    "${targetName}StdAlloc",
-                    "${targetName}Objc"
-            )
-    ) {
-        headersDirs += files("src/gc/cms/cpp", "src/gc/common/cpp", "src/mm/cpp")
-        includeRuntime()
-    })
+    testsGroup("experimentalMM_noop_mimalloc_runtime_tests", listOf("main", "experimental_memory_manager", "common_gc", "noop_gc", "mimalloc", "opt_alloc", "objc"))

-    allTests.addAll(createTestTasks(
-            project,
-            targetName,
-            "${targetName}ExperimentalMMNoOpMimallocRuntimeTests",
-            listOf(
-                "${targetName}Runtime",
-                "${targetName}ExperimentalMemoryManager",
-                "${targetName}CommonGc",
-                "${targetName}NoopGc",
-                "${targetName}Mimalloc",
-                "${targetName}OptAlloc",
-                "${targetName}Objc"
-            )
-    ) {
-        headersDirs += files("src/gc/noop/cpp", "src/gc/common/cpp", "src/mm/cpp")
-        includeRuntime()
-    })
-
-    allTests.addAll(createTestTasks(
-            project,
-            targetName,
-            "${targetName}ExperimentalMMNoOpStdAllocRuntimeTests",
-            listOf(
-                "${targetName}Runtime",
-                "${targetName}ExperimentalMemoryManager",
-                "${targetName}CommonGc",
-                "${targetName}NoopGc",
-                "${targetName}StdAlloc",
-                "${targetName}Objc"
-            )
-    ) {
-        headersDirs += files("src/gc/noop/cpp", "src/gc/common/cpp", "src/mm/cpp")
-        includeRuntime()
-    })
-
-    // TODO: This "all tests" tasks should be provided by `CompileToBitcodeExtension`
-    tasks.register("${targetName}RuntimeTests") {
-        dependsOn(allTests)
-    }
+    testsGroup("experimentalMM_noop_std_alloc_runtime_tests", listOf("main", "experimental_memory_manager", "common_gc", "noop_gc", "std_alloc", "objc"))
 }

 val hostRuntime by tasks.registering {
@@ -357,32 +207,12 @@ val hostRuntimeTests by tasks.registering {
    dependsOn("${hostName}RuntimeTests")
 }

-val hostStdAllocRuntimeTests by tasks.registering {
-    dependsOn("${hostName}StdAllocRuntimeTests")
-}
-
-val hostMimallocRuntimeTests by tasks.registering {
-    dependsOn("${hostName}MimallocRuntimeTests")
-}
-
-val hostExperimentalMMStdAllocRuntimeTests by tasks.registering {
-    dependsOn("${hostName}ExperimentalMMStdAllocRuntimeTests")
-}
-
-val hostExperimentalMMMimallocRuntimeTests by tasks.registering {
-    dependsOn("${hostName}ExperimentalMMMimallocRuntimeTests")
-}
-
 val assemble by tasks.getting {
-    dependsOn(tasks.withType(CompileToBitcode::class).matching {
-        it.outputGroup == "main"
-    })
+    dependsOn(targetList.forEach { "${it}Runtime" })
 }

 val hostAssemble by tasks.registering {
-    dependsOn(tasks.withType(CompileToBitcode::class).matching {
-        it.outputGroup == "main" && it.target == hostName
-    })
+    dependsOn("${hostName}Runtime")
 }

 val clean by tasks.getting {