Remove -Xnormalize-constructor-calls

Constructor call normalization is enabled by default since 1.3.
2021-09-02 02:09:18 +02:00
parent cc3ad73436
commit 1864716c83
36 changed files with 83 additions and 400 deletions
@@ -127,7 +127,6 @@ public class FunctionCodegen {
                        CoroutineCodegenUtilKt.<FunctionDescriptor>unwrapInitialDescriptorForSuspendFunction(functionDescriptor),
                        function,
                        v.getThisName(),
-                        state.getConstructorCallNormalizationMode(),
                        this
                );
            } else {
@@ -160,8 +160,6 @@ class CoroutineCodegenForLambda private constructor(
 ) {
    private val builtIns = funDescriptor.builtIns

-    private val constructorCallNormalizationMode = outerExpressionCodegen.state.constructorCallNormalizationMode
-
    private val erasedInvokeFunction by lazy {
        getErasedInvokeFunction(funDescriptor).createCustomCopy { setModality(Modality.FINAL) }
    }
@@ -524,7 +522,6 @@ class CoroutineCodegenForLambda private constructor(
                        containingClassInternalName = v.thisName,
                        obtainClassBuilderForCoroutineState = { v },
                        isForNamedFunction = false,
-                        shouldPreserveClassInitialization = constructorCallNormalizationMode.shouldPreserveClassInitialization,
                        disableTailCallOptimizationForFunctionReturningUnit = false,
                        reportSuspensionPointInsideMonitor = { reportSuspensionPointInsideMonitor(element, state, it) },
                        lineNumber = CodegenUtil.getLineNumberForElement(element, false) ?: 0,
@@ -12,7 +12,10 @@ import org.jetbrains.kotlin.codegen.optimization.fixStack.FixStackMethodTransfor
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.utils.sure
-import org.jetbrains.org.objectweb.asm.*
+import org.jetbrains.org.objectweb.asm.Label
+import org.jetbrains.org.objectweb.asm.MethodVisitor
+import org.jetbrains.org.objectweb.asm.Opcodes
+import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 import org.jetbrains.org.objectweb.asm.tree.*
 import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
@@ -43,7 +46,6 @@ class CoroutineTransformerMethodVisitor(
    private val containingClassInternalName: String,
    obtainClassBuilderForCoroutineState: () -> ClassBuilder,
    private val isForNamedFunction: Boolean,
-    private val shouldPreserveClassInitialization: Boolean,
    // Since tail-call optimization of functions with Unit return type relies on ability of call-site to recognize them,
    // in order to ignore return value and push Unit, when we cannot ensure this ability, for example, when the function overrides function,
    // returning Any, we need to disable tail-call optimization for these functions.
@@ -121,7 +123,7 @@ class CoroutineTransformerMethodVisitor(
        // Actual max stack might be increased during the previous phases
        methodNode.updateMaxStack()

-        UninitializedStoresProcessor(methodNode, shouldPreserveClassInitialization).run()
+        UninitializedStoresProcessor(methodNode).run()

        val spilledToVariableMapping = spillVariables(suspensionPoints, methodNode)

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.codegen.inline.coroutines.FOR_INLINE_SUFFIX
 import org.jetbrains.kotlin.codegen.inline.preprocessSuspendMarkers
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
-import org.jetbrains.kotlin.config.JVMConstructorCallNormalizationMode
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
@@ -37,7 +36,6 @@ class SuspendFunctionGenerationStrategy(
    private val originalSuspendDescriptor: FunctionDescriptor,
    private val declaration: KtFunction,
    private val containingClassInternalName: String,
-    private val constructorCallNormalizationMode: JVMConstructorCallNormalizationMode,
    private val functionCodegen: FunctionCodegen
 ) : FunctionGenerationStrategy.CodegenBased(state) {

@@ -88,7 +86,6 @@ class SuspendFunctionGenerationStrategy(
        return CoroutineTransformerMethodVisitor(
            mv, access, name, desc, null, null, containingClassInternalName, this::classBuilderForCoroutineState,
            isForNamedFunction = true,
-            shouldPreserveClassInitialization = constructorCallNormalizationMode.shouldPreserveClassInitialization,
            disableTailCallOptimizationForFunctionReturningUnit = originalSuspendDescriptor.returnType?.isUnit() == true &&
                    originalSuspendDescriptor.overriddenDescriptors.isNotEmpty() &&
                    !originalSuspendDescriptor.allOverriddenFunctionsReturnUnit(),
@@ -72,10 +72,7 @@ import kotlin.math.max
 *   - generate NEW/DUP
 *   - restore constructor arguments
 */
-class UninitializedStoresProcessor(
-    private val methodNode: MethodNode,
-    private val shouldPreserveClassInitialization: Boolean
-) {
+class UninitializedStoresProcessor(private val methodNode: MethodNode) {
    // <init> method is "special", because it will invoke <init> from this class or from a base class for #0
    //
    // <clinit> method is "special", because <clinit> for singleton objects is generated as:
@@ -107,22 +104,7 @@ class UninitializedStoresProcessor(

            methodNode.instructions.run {
                removeAll(removableUsages)
-
-                if (shouldPreserveClassInitialization) {
-                    // Replace 'NEW C' instruction with "manual" initialization of class 'C':
-                    //      LDC [typeName for C]
-                    //      INVOKESTATIC java/lang/Class.forName (Ljava/lang/String;)Ljava/lang/Class;
-                    //      POP
-                    val typeNameForClass = newInsn.desc.replace('/', '.')
-                    insertBefore(newInsn, LdcInsnNode(typeNameForClass))
-                    insertBefore(
-                        newInsn,
-                        MethodInsnNode(Opcodes.INVOKESTATIC, "java/lang/Class", "forName", "(Ljava/lang/String;)Ljava/lang/Class;", false)
-                    )
-                    set(newInsn, InsnNode(Opcodes.POP))
-                } else {
-                    remove(newInsn)
-                }
+                remove(newInsn)
            }

            val indexOfConstructorArgumentFromTopOfStack = Type.getArgumentTypes((insn as MethodInsnNode).desc).size
@@ -87,7 +87,6 @@ class CoroutineTransformer(
                containingClassInternalName = classBuilder.thisName,
                obtainClassBuilderForCoroutineState = { classBuilder },
                isForNamedFunction = false,
-                shouldPreserveClassInitialization = state.constructorCallNormalizationMode.shouldPreserveClassInitialization,
                disableTailCallOptimizationForFunctionReturningUnit = false,
                reportSuspensionPointInsideMonitor = { sourceCompilerForInline.reportSuspensionPointInsideMonitor(it) },
                // TODO: this linenumbers might not be correct and since they are used only for step-over, check them.
@@ -121,7 +120,6 @@ class CoroutineTransformer(
                containingClassInternalName = classBuilder.thisName,
                obtainClassBuilderForCoroutineState = { (inliningContext as RegeneratedClassContext).continuationBuilders[continuationClassName]!! },
                isForNamedFunction = true,
-                shouldPreserveClassInitialization = state.constructorCallNormalizationMode.shouldPreserveClassInitialization,
                disableTailCallOptimizationForFunctionReturningUnit = disableTailCallOptimization,
                reportSuspensionPointInsideMonitor = { sourceCompilerForInline.reportSuspensionPointInsideMonitor(it) },
                lineNumber = inliningContext.callSiteInfo.lineNumber,
@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.codegen.optimization

 import org.jetbrains.kotlin.codegen.TransformationMethodVisitor
+import org.jetbrains.kotlin.codegen.coroutines.UninitializedStoresProcessor
 import org.jetbrains.kotlin.codegen.inline.InplaceArgumentsMethodTransformer
 import org.jetbrains.kotlin.codegen.optimization.boxing.PopBackwardPropagationTransformer
 import org.jetbrains.kotlin.codegen.optimization.boxing.RedundantBoxingMethodTransformer
@@ -38,9 +39,6 @@ class OptimizationMethodVisitor(
    signature: String?,
    exceptions: Array<String>?
 ) : TransformationMethodVisitor(delegate, access, name, desc, signature, exceptions) {
-    private val constructorCallNormalizationTransformer =
-        UninitializedStoresMethodTransformer(generationState.constructorCallNormalizationMode)
-
    val normalizationMethodTransformer = CompositeMethodTransformer(
        InplaceArgumentsMethodTransformer(),
        FixStackWithLabelNormalizationMethodTransformer(),
@@ -65,7 +63,7 @@ class OptimizationMethodVisitor(

    override fun performTransformations(methodNode: MethodNode) {
        normalizationMethodTransformer.transform("fake", methodNode)
-        constructorCallNormalizationTransformer.transform("fake", methodNode)
+        UninitializedStoresProcessor(methodNode).run()

        if (canBeOptimized(methodNode) && !generationState.disableOptimization) {
            optimizationTransformer.transform("fake", methodNode)
@@ -1,34 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.codegen.optimization
-
-import org.jetbrains.kotlin.codegen.coroutines.UninitializedStoresProcessor
-import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
-import org.jetbrains.kotlin.config.JVMConstructorCallNormalizationMode
-import org.jetbrains.org.objectweb.asm.tree.MethodNode
-
-class UninitializedStoresMethodTransformer(
-    private val mode: JVMConstructorCallNormalizationMode
-) : MethodTransformer() {
-
-    override fun transform(internalClassName: String, methodNode: MethodNode) {
-        if (mode.isEnabled) {
-            UninitializedStoresProcessor(methodNode, mode.shouldPreserveClassInitialization).run()
-        }
-    }
-
-}
@@ -312,14 +312,6 @@ class GenerationState private constructor(

    val shouldInlineConstVals = languageVersionSettings.supportsFeature(LanguageFeature.InlineConstVals)

-    val constructorCallNormalizationMode =
-        configuration.get(JVMConfigurationKeys.CONSTRUCTOR_CALL_NORMALIZATION_MODE) ?: run {
-            if (languageVersionSettings.supportsFeature(LanguageFeature.NormalizeConstructorCalls))
-                JVMConstructorCallNormalizationMode.ENABLE
-            else
-                JVMConstructorCallNormalizationMode.DISABLE
-        }
-
    val jvmDefaultMode = languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode)

    val disableOptimization = configuration.get(JVMConfigurationKeys.DISABLE_OPTIMIZATION, false)