JVM_IR: introduce modes for IR serialization

Instead of a Boolean flag -Xserialize-ir, use modes: none,inline,all. In "inline" mode, only information needed to deserialize bodies of inline functions is serialized. In the "all" mode, all declarations are serialized completely.
2021-09-09 13:35:23 +03:00
parent f760cd6736
commit 4caa71538d
12 changed files with 55 additions and 16 deletions
@@ -488,9 +488,10 @@ default: `indy-with-constants` for JVM target 9 or greater, `inline` otherwise""

    @Argument(
        value = "-Xserialize-ir",
+        valueDescription = "{none|inline|all}",
        description = "Save IR to metadata (EXPERIMENTAL)"
    )
-    var serializeIr: Boolean by FreezableVar(false)
+    var serializeIr: String by FreezableVar("none")

    @Argument(
        value = "-Xvalidate-ir",
@@ -255,7 +255,7 @@ fun CompilerConfiguration.configureAdvancedJvmOptions(arguments: K2JVMCompilerAr
    put(JVMConfigurationKeys.NO_RESET_JAR_TIMESTAMPS, arguments.noResetJarTimestamps)
    put(JVMConfigurationKeys.NO_UNIFIED_NULL_CHECKS, arguments.noUnifiedNullChecks)

-    put(JVMConfigurationKeys.SERIALIZE_IR, arguments.serializeIr)
+    put(JVMConfigurationKeys.SERIALIZE_IR, JvmSerializeIrMode.fromString(arguments.serializeIr))

    put(JVMConfigurationKeys.VALIDATE_IR, arguments.validateIr)
    put(JVMConfigurationKeys.VALIDATE_BYTECODE, arguments.validateBytecode)
@@ -145,8 +145,8 @@ public class JVMConfigurationKeys {
    public static final CompilerConfigurationKey<Boolean> NO_REFLECT =
            CompilerConfigurationKey.create("Don't automatically include kotlin-reflect.jar into the output if the output is a jar");

-    public static final CompilerConfigurationKey<Boolean> SERIALIZE_IR =
-            CompilerConfigurationKey.create("Serialize IR to class metadata");
+    public static final CompilerConfigurationKey<JvmSerializeIrMode> SERIALIZE_IR =
+            CompilerConfigurationKey.create("What functions to serialize as IR to class metadata");

    public static final CompilerConfigurationKey<Boolean> VALIDATE_IR =
            CompilerConfigurationKey.create("Validate IR");
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.config
+
+enum class JvmSerializeIrMode(val description: String) {
+    NONE("none"),
+    INLINE("inline"),
+    ALL("all");
+
+    companion object {
+        @JvmStatic
+        fun fromStringOrNull(string: String) = values().find { it.description == string }
+
+        @JvmStatic
+        fun fromString(string: String) = fromStringOrNull(string) ?: NONE
+    }
+}
@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.backend.jvm.serialization.deserializeClassFromByteAr
 import org.jetbrains.kotlin.backend.jvm.serialization.deserializeIrFileFromByteArray
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.config.JvmSerializeIrMode
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.FilteredAnnotations
@@ -69,7 +70,7 @@ open class JvmGeneratorExtensionsImpl(
 ) : GeneratorExtensions(), JvmGeneratorExtensions {
    override val classNameOverride: MutableMap<IrClass, JvmClassName> = mutableMapOf()

-    override val irDeserializationEnabled: Boolean = configuration.getBoolean(JVMConfigurationKeys.SERIALIZE_IR)
+    override val irDeserializationEnabled: Boolean = configuration.get(JVMConfigurationKeys.SERIALIZE_IR) != JvmSerializeIrMode.NONE

    override val cachedFields = CachedFieldsForObjectInstances(IrFactoryImpl, configuration.languageVersionSettings)

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.codegen.CodegenFactory
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.config.JvmSerializeIrMode
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.konan.DeserializedKlibModuleOrigin
 import org.jetbrains.kotlin.descriptors.konan.KlibModuleOrigin
@@ -209,7 +210,9 @@ open class JvmIrCodegenFactory(
    override fun generateModule(state: GenerationState, input: CodegenFactory.BackendInput) {
        val (irModuleFragment, symbolTable, customPhaseConfig, irProviders, extensions, backendExtension, notifyCodegenStart) =
            input as JvmIrBackendInput
-        val irSerializer = if (state.configuration.getBoolean(JVMConfigurationKeys.SERIALIZE_IR))
+        val irSerializer = if (
+            state.configuration.get(JVMConfigurationKeys.SERIALIZE_IR, JvmSerializeIrMode.NONE) != JvmSerializeIrMode.NONE
+        )
            JvmIrSerializerImpl(state.configuration)
        else null
        val phaseConfig = customPhaseConfig ?: PhaseConfig(jvmPhases)
@@ -9,6 +9,8 @@ import org.jetbrains.kotlin.backend.common.serialization.DeclarationTable
 import org.jetbrains.kotlin.backend.jvm.serialization.JvmGlobalDeclarationTable
 import org.jetbrains.kotlin.backend.jvm.serialization.JvmIrSerializerSession
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.config.JvmSerializeIrMode
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.util.IrMessageLogger
@@ -31,5 +33,6 @@ class JvmIrSerializerImpl(private val configuration: CompilerConfiguration) : Jv
            configuration.get(IrMessageLogger.IR_MESSAGE_LOGGER) ?: IrMessageLogger.None,
            declarationTable,
            mutableMapOf(),
+            configuration.get(JVMConfigurationKeys.SERIALIZE_IR) ?: JvmSerializeIrMode.NONE
        )
 }
@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.backend.common.serialization.CompatibilityMode
 import org.jetbrains.kotlin.backend.common.serialization.DeclarationTable
 import org.jetbrains.kotlin.backend.common.serialization.IrFileSerializer
 import org.jetbrains.kotlin.backend.jvm.serialization.proto.JvmIr
+import org.jetbrains.kotlin.config.JvmSerializeIrMode
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrFile
@@ -20,11 +21,16 @@ class JvmIrSerializerSession(
    messageLogger: IrMessageLogger,
    private val declarationTable: DeclarationTable,
    expectDescriptorToSymbol: MutableMap<DeclarationDescriptor, IrSymbol>,
-    externallyVisibleOnly: Boolean = true,
+    mode: JvmSerializeIrMode,
    skipExpects: Boolean = false,
 ) : IrFileSerializer(
-    messageLogger, declarationTable, expectDescriptorToSymbol, CompatibilityMode.CURRENT, externallyVisibleOnly, skipExpects
+    messageLogger, declarationTable, expectDescriptorToSymbol, CompatibilityMode.CURRENT,
+    bodiesOnlyForInlines = mode == JvmSerializeIrMode.INLINE,
+    skipExpects
 ) {
+    init {
+        assert(mode != JvmSerializeIrMode.NONE)
+    }

    // Usage protocol: construct an instance, call only one of `serializeIrFile()` and `serializeTopLevelClass()` only once.

@@ -107,7 +107,8 @@ where advanced options include:
                             problems with parentheses in identifiers on certain platforms
  -Xscript-resolver-environment=<key=value[,]>
                             Script resolver environment in key-value pairs (the value could be quoted and escaped)
-  -Xserialize-ir             Save IR to metadata (EXPERIMENTAL)
+  -Xserialize-ir={none|inline|all}
+                             Save IR to metadata (EXPERIMENTAL)
  -Xsingle-module            Combine modules for source files and binary dependencies into a single module
  -Xskip-runtime-version-check Allow Kotlin runtime libraries of incompatible versions in the classpath
  -Xgenerate-strict-metadata-version
@@ -5,10 +5,7 @@

 package org.jetbrains.kotlin.test.directives

-import org.jetbrains.kotlin.config.JVMAssertionsMode
-import org.jetbrains.kotlin.config.JvmClosureGenerationScheme
-import org.jetbrains.kotlin.config.JvmStringConcat
-import org.jetbrains.kotlin.config.JvmTarget
+import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.test.TestJavacVersion
 import org.jetbrains.kotlin.test.TestJdkKind
 import org.jetbrains.kotlin.test.directives.model.DirectiveApplicability
@@ -86,7 +83,8 @@ object JvmEnvironmentConfigurationDirectives : SimpleDirectivesContainer() {
        description = "Enable old mangling scheme for inline classes"
    )

-    val SERIALIZE_IR by directive(
-        description = "Enable serialization of JVM IR"
+    val SERIALIZE_IR by enumDirective(
+        description = "Enable serialization of JVM IR",
+        additionalParser = JvmSerializeIrMode.Companion::fromString
    )
 }
@@ -5,6 +5,7 @@

 package org.jetbrains.kotlin.test.runners.codegen

+import org.jetbrains.kotlin.config.JvmSerializeIrMode
 import org.jetbrains.kotlin.test.Constructor
 import org.jetbrains.kotlin.test.TargetBackend
 import org.jetbrains.kotlin.test.TestInfrastructureInternals
@@ -74,7 +75,7 @@ open class AbstractIrSerializeCompileKotlinAgainstInlineKotlinTest : AbstractIrC
        super.configure(builder)
        builder.apply {
            defaultDirectives {
-                +SERIALIZE_IR
+                SERIALIZE_IR.with(JvmSerializeIrMode.INLINE)
            }

            configureIrHandlersStep {
@@ -39,6 +39,11 @@ private val patterns = buildList {
        "USE_OLD_INLINE_CLASSES_MANGLING_SCHEME",
        JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME,
    )
+    createPattern(
+        "SERIALIZE_IR",
+        JVMConfigurationKeys.SERIALIZE_IR,
+        JvmSerializeIrMode.Companion::fromString,
+    )
 }

 private sealed class PatternWithExtractor<E : Any> {