JVM skip methods without NEW insns in UninitializedStoresProcessor

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/processUninitializedStores.kt

@@ -73,8 +73,8 @@ import kotlin.math.max
  *   - restore constructor arguments
  */
 class UninitializedStoresProcessor(
-        private val methodNode: MethodNode,
-        private val shouldPreserveClassInitialization: Boolean
+    private val methodNode: MethodNode,
+    private val shouldPreserveClassInitialization: Boolean
 ) {
     // <init> method is "special", because it will invoke <init> from this class or from a base class for #0
     //
@@ -87,10 +87,10 @@ class UninitializedStoresProcessor(
     fun run() {
         val interpreter = UninitializedNewValueMarkerInterpreter(methodNode.instructions)
 
-        val frames = CustomFramesMethodAnalyzer(
-                "fake", methodNode, interpreter,
-                this::UninitializedNewValueFrame
-        ).analyze()
+        if (methodNode.instructions.toArray().none { it.opcode == Opcodes.NEW })
+            return
+
+        val frames = CustomFramesMethodAnalyzer("fake", methodNode, interpreter, this::UninitializedNewValueFrame).analyze()
 
         interpreter.analyzePopInstructions(frames)
 
@@ -115,12 +115,12 @@ class UninitializedStoresProcessor(
                     //      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
-                    ))
+                    insertBefore(
+                        newInsn,
+                        MethodInsnNode(Opcodes.INVOKESTATIC, "java/lang/Class", "forName", "(Ljava/lang/String;)Ljava/lang/Class;", false)
+                    )
                     set(newInsn, InsnNode(Opcodes.POP))
-                }
-                else {
+                } else {
                     remove(newInsn)
                 }
             }
@@ -138,10 +138,7 @@ class UninitializedStoresProcessor(
             }
             methodNode.maxLocals = max(methodNode.maxLocals, nextVarIndex)
 
-            methodNode.instructions.insertBefore(insn, insnListOf(
-                    TypeInsnNode(Opcodes.NEW, newInsn.desc),
-                    InsnNode(Opcodes.DUP)
-            ))
+            methodNode.instructions.insertBefore(insn, insnListOf(TypeInsnNode(Opcodes.NEW, newInsn.desc), InsnNode(Opcodes.DUP)))
 
             for (type in storedTypes.reversed()) {
                 nextVarIndex -= type.size
@@ -174,11 +171,10 @@ class UninitializedStoresProcessor(
 
         assert(insn.opcode == Opcodes.INVOKESPECIAL) { "Expected opcode Opcodes.INVOKESPECIAL for <init>, but ${insn.opcode} found" }
         val paramsCountIncludingReceiver = Type.getArgumentTypes((insn as MethodInsnNode).desc).size + 1
-        val newValue = peek(paramsCountIncludingReceiver) as? UninitializedNewValue ?:
-                       if (isInSpecialMethod)
-                           return null
-                       else
-                           error("Expected value generated with NEW")
+        val newValue = peek(paramsCountIncludingReceiver) as? UninitializedNewValue ?: if (isInSpecialMethod)
+            return null
+        else
+            error("Expected value generated with NEW")
 
         assert(peek(paramsCountIncludingReceiver - 1) is UninitializedNewValue) {
             "Next value after NEW should be one generated by DUP"
@@ -188,8 +184,8 @@ class UninitializedStoresProcessor(
     }
 
     private class UninitializedNewValue(
-            val newInsn: TypeInsnNode,
-            val internalName: String
+        val newInsn: TypeInsnNode,
+        val internalName: String
     ) : StrictBasicValue(Type.getObjectType(internalName)) {
         override fun toString() = "UninitializedNewValue(internalName='$internalName')"
     }
@@ -236,7 +232,8 @@ class UninitializedStoresProcessor(
 
         private fun checkUninitializedObjectCopy(newInsn: TypeInsnNode, usageInsn: AbstractInsnNode) {
             when (usageInsn.opcode) {
-                Opcodes.DUP, Opcodes.ASTORE, Opcodes.ALOAD -> {}
+                Opcodes.DUP, Opcodes.ASTORE, Opcodes.ALOAD -> {
+                }
                 else -> error("Unexpected copy instruction for ${newInsn.debugText}: ${usageInsn.debugText}")
             }
         }

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/MethodInliner.kt

@@ -17,8 +17,8 @@ import org.jetbrains.kotlin.codegen.optimization.common.ControlFlowGraph
 import org.jetbrains.kotlin.codegen.optimization.common.InsnSequence
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
 import org.jetbrains.kotlin.codegen.optimization.common.isMeaningful
-import org.jetbrains.kotlin.codegen.optimization.fixStack.peek
-import org.jetbrains.kotlin.codegen.optimization.fixStack.top
+import org.jetbrains.kotlin.codegen.optimization.fixStack.*
+import org.jetbrains.kotlin.codegen.optimization.fixStack.FastStackAnalyzer
 import org.jetbrains.kotlin.codegen.optimization.nullCheck.isCheckParameterIsNotNull
 import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsn
 import org.jetbrains.kotlin.config.LanguageFeature
@@ -36,8 +36,6 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 import org.jetbrains.org.objectweb.asm.commons.LocalVariablesSorter
 import org.jetbrains.org.objectweb.asm.commons.MethodRemapper
 import org.jetbrains.org.objectweb.asm.tree.*
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicInterpreter
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 import org.jetbrains.org.objectweb.asm.util.Printer
 import java.util.*
@@ -57,8 +55,10 @@ class MethodInliner(
 ) {
     private val languageVersionSettings = inliningContext.state.languageVersionSettings
     private val invokeCalls = ArrayList<InvokeCall>()
+
     //keeps order
     private val transformations = ArrayList<TransformationInfo>()
+
     //current state
     private val currentTypeMapping = HashMap<String, String?>()
     private val result = InlineResult.create()
@@ -273,7 +273,8 @@ class MethodInliner(
 
                     val varRemapper = LocalVarRemapper(lambdaParameters, valueParamShift)
                     //TODO add skipped this and receiver
-                    val lambdaResult = inliner.doInline(localVariablesSorter, varRemapper, true, info.returnLabels, invokeCall.finallyDepthShift)
+                    val lambdaResult =
+                        inliner.doInline(localVariablesSorter, varRemapper, true, info.returnLabels, invokeCall.finallyDepthShift)
                     result.mergeWithNotChangeInfo(lambdaResult)
                     result.reifiedTypeParametersUsages.mergeAll(lambdaResult.reifiedTypeParametersUsages)
                     result.reifiedTypeParametersUsages.mergeAll(info.reifiedTypeParametersUsages)
@@ -303,7 +304,7 @@ class MethodInliner(
                             } else capturedParamDesc
                             visitFieldInsn(
                                 Opcodes.GETSTATIC, realDesc.containingLambdaName,
-                                FieldRemapper.foldName(realDesc.fieldName), realDesc.type.descriptor
+                                foldName(realDesc.fieldName), realDesc.type.descriptor
                             )
                         }
                         super.visitMethodInsn(opcode, info.newClassName, name, info.newConstructorDescriptor, itf)
@@ -441,7 +442,7 @@ class MethodInliner(
                         else -> ""
                     }
 
-                    val varName = if (!varSuffix.isEmpty() && name == AsmUtil.THIS) AsmUtil.INLINE_DECLARATION_SITE_THIS else name
+                    val varName = if (varSuffix.isNotEmpty() && name == AsmUtil.THIS) AsmUtil.INLINE_DECLARATION_SITE_THIS else name
                     super.visitLocalVariable(varName + varSuffix, desc, signature, start, end, getNewIndex(index))
                 }
             }
@@ -533,33 +534,37 @@ class MethodInliner(
                     cur.opcode == Opcodes.GETSTATIC -> {
                         val fieldInsnNode = cur as FieldInsnNode?
                         val className = fieldInsnNode!!.owner
-                        if (isAnonymousSingletonLoad(className, fieldInsnNode.name)) {
-                            recordTransformation(
-                                AnonymousObjectTransformationInfo(
-                                    className, awaitClassReification, isAlreadyRegenerated(className), true,
-                                    inliningContext.nameGenerator
+                        when {
+                            isAnonymousSingletonLoad(className, fieldInsnNode.name) -> {
+                                recordTransformation(
+                                    AnonymousObjectTransformationInfo(
+                                        className, awaitClassReification, isAlreadyRegenerated(className), true,
+                                        inliningContext.nameGenerator
+                                    )
                                 )
-                            )
-                            awaitClassReification = false
-                        } else if (isWhenMappingAccess(className, fieldInsnNode.name)) {
-                            recordTransformation(
-                                WhenMappingTransformationInfo(
-                                    className, inliningContext.nameGenerator, isAlreadyRegenerated(className), fieldInsnNode
+                                awaitClassReification = false
+                            }
+                            isWhenMappingAccess(className, fieldInsnNode.name) -> {
+                                recordTransformation(
+                                    WhenMappingTransformationInfo(
+                                        className, inliningContext.nameGenerator, isAlreadyRegenerated(className), fieldInsnNode
+                                    )
                                 )
-                            )
-                        } else if (fieldInsnNode.isCheckAssertionsStatus()) {
-                            fieldInsnNode.owner = inlineCallSiteInfo.ownerClassName
-                            when {
-                                // In inline function itself:
-                                inliningContext.parent == null -> inliningContext
-                                // In method of regenerated object - field should already exist:
-                                inliningContext.parent is RegeneratedClassContext -> inliningContext.parent
-                                // In lambda inlined into the root function:
-                                inliningContext.parent.parent == null -> inliningContext.parent
-                                // In lambda inlined into a method of a regenerated object:
-                                else -> inliningContext.parent.parent as? RegeneratedClassContext
-                                    ?: throw AssertionError("couldn't find class for \$assertionsDisabled (context = $inliningContext)")
-                            }.generateAssertField = true
+                            }
+                            fieldInsnNode.isCheckAssertionsStatus() -> {
+                                fieldInsnNode.owner = inlineCallSiteInfo.ownerClassName
+                                when {
+                                    // In inline function itself:
+                                    inliningContext.parent == null -> inliningContext
+                                    // In method of regenerated object - field should already exist:
+                                    inliningContext.parent is RegeneratedClassContext -> inliningContext.parent
+                                    // In lambda inlined into the root function:
+                                    inliningContext.parent.parent == null -> inliningContext.parent
+                                    // In lambda inlined into a method of a regenerated object:
+                                    else -> inliningContext.parent.parent as? RegeneratedClassContext
+                                        ?: throw AssertionError("couldn't find class for \$assertionsDisabled (context = $inliningContext)")
+                                }.generateAssertField = true
+                            }
                         }
                     }
 
@@ -588,7 +593,7 @@ class MethodInliner(
                                 assert(lambdaInfo.lambdaClassType.internalName == nodeRemapper.originalLambdaInternalName) {
                                     "Wrong bytecode template for contract template: ${lambdaInfo.lambdaClassType.internalName} != ${nodeRemapper.originalLambdaInternalName}"
                                 }
-                                fieldInsn.name = FieldRemapper.foldName(fieldInsn.name)
+                                fieldInsn.name = foldName(fieldInsn.name)
                                 fieldInsn.opcode = Opcodes.PUTSTATIC
                                 toDelete.addAll(stackTransformations)
                             }
@@ -742,7 +747,7 @@ class MethodInliner(
             ApiVersionCallsPreprocessingMethodTransformer(targetApiVersion).transform("fake", node)
         }
 
-        val frames = analyzeMethodNodeWithInterpreter(node, BasicInterpreter())
+        val frames = FastStackAnalyzer("<fake>", node, FixStackInterpreter()).analyze()
 
         val localReturnsNormalizer = LocalReturnsNormalizer()
 
@@ -831,9 +836,9 @@ class MethodInliner(
         if (inliningContext.isInliningLambda && inliningContext.lambdaInfo is IrExpressionLambda && !inliningContext.parent!!.isInliningLambda) {
             val capturedVars = inliningContext.lambdaInfo.capturedVars
             var offset = parameters.realParametersSizeOnStack
-            val map = capturedVars.map {
+            val map = capturedVars.associate {
                 offset to it.also { offset += it.type.size }
-            }.toMap()
+            }
 
             var cur: AbstractInsnNode? = node.instructions.first
             while (cur != null) {
@@ -878,6 +883,7 @@ class MethodInliner(
         }
     }
 
+    @Suppress("SameParameterValue")
     private fun wrapException(originalException: Throwable, node: MethodNode, errorSuffix: String): RuntimeException {
         return if (originalException is InlineException) {
             InlineException("$errorPrefix: $errorSuffix", originalException)
@@ -890,7 +896,7 @@ class MethodInliner(
         private class LocalReturn(
             private val returnInsn: AbstractInsnNode,
             private val insertBeforeInsn: AbstractInsnNode,
-            private val frame: Frame<BasicValue>
+            private val frame: Frame<FixStackValue>
         ) {
 
             fun transform(insnList: InsnList, returnVariableIndex: Int) {
@@ -901,22 +907,19 @@ class MethodInliner(
                 if (expectedStackSize == actualStackSize) return
 
                 var stackSize = actualStackSize
+                val topValue = frame.getStack(stackSize - 1)
                 if (isReturnWithValue) {
-                    val storeOpcode = Opcodes.ISTORE + returnInsn.opcode - Opcodes.IRETURN
-                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(storeOpcode, returnVariableIndex))
+                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(topValue.storeOpcode, returnVariableIndex))
                     stackSize--
                 }
 
                 while (stackSize > 0) {
-                    val stackElementSize = frame.getStack(stackSize - 1).size
-                    val popOpcode = if (stackElementSize == 1) Opcodes.POP else Opcodes.POP2
-                    insnList.insertBefore(insertBeforeInsn, InsnNode(popOpcode))
+                    insnList.insertBefore(insertBeforeInsn, InsnNode(frame.getStack(stackSize - 1).popOpcode))
                     stackSize--
                 }
 
                 if (isReturnWithValue) {
-                    val loadOpcode = Opcodes.ILOAD + returnInsn.opcode - Opcodes.IRETURN
-                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(loadOpcode, returnVariableIndex))
+                    insnList.insertBefore(insertBeforeInsn, VarInsnNode(topValue.loadOpcode, returnVariableIndex))
                 }
             }
         }
@@ -926,10 +929,10 @@ class MethodInliner(
         private var returnVariableSize = 0
         private var returnOpcode = -1
 
-        internal fun addLocalReturnToTransform(
+        fun addLocalReturnToTransform(
             returnInsn: AbstractInsnNode,
             insertBeforeInsn: AbstractInsnNode,
-            sourceValueFrame: Frame<BasicValue>
+            sourceValueFrame: Frame<FixStackValue>
         ) {
             assert(isReturnOpcode(returnInsn.opcode)) { "return instruction expected" }
             assert(returnOpcode < 0 || returnOpcode == returnInsn.opcode) { "Return op should be " + Printer.OPCODES[returnOpcode] + ", got " + Printer.OPCODES[returnInsn.opcode] }
@@ -938,11 +941,7 @@ class MethodInliner(
             localReturns.add(LocalReturn(returnInsn, insertBeforeInsn, sourceValueFrame))
 
             if (returnInsn.opcode != Opcodes.RETURN) {
-                returnVariableSize = if (returnInsn.opcode == Opcodes.LRETURN || returnInsn.opcode == Opcodes.DRETURN) {
-                    2
-                } else {
-                    1
-                }
+                returnVariableSize = if (returnInsn.opcode == Opcodes.LRETURN || returnInsn.opcode == Opcodes.DRETURN) 2 else 1
             }
         }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/OptimizationMethodVisitor.kt

@@ -73,24 +73,29 @@ class OptimizationMethodVisitor(
 
     companion object {
         private const val MEMORY_LIMIT_BY_METHOD_MB = 50
-        private const val TRY_CATCH_BLOCKS_LIMIT = 512
+        private const val TRY_CATCH_BLOCKS_SOFT_LIMIT = 16
 
         fun canBeOptimized(node: MethodNode): Boolean {
-            if (node.tryCatchBlocks.size > TRY_CATCH_BLOCKS_LIMIT)
-                return false
-
-            val totalFramesSizeMb = node.instructions.size() * (node.maxLocals + node.maxStack) / (1024 * 1024)
-            return totalFramesSizeMb < MEMORY_LIMIT_BY_METHOD_MB
+            if (node.tryCatchBlocks.size > TRY_CATCH_BLOCKS_SOFT_LIMIT) {
+                if (getTotalFramesWeight(getTotalTcbSize(node), node) > MEMORY_LIMIT_BY_METHOD_MB)
+                    return false
+            }
+            return getTotalFramesWeight(node.instructions.size(), node) < MEMORY_LIMIT_BY_METHOD_MB
         }
 
         fun canBeOptimizedUsingSourceInterpreter(node: MethodNode): Boolean {
-            if (node.tryCatchBlocks.size > TRY_CATCH_BLOCKS_LIMIT)
-                return false
-
-            val frameSize = node.maxLocals + node.maxStack
-            val methodSize = node.instructions.size().toLong()
-            val totalFramesSizeMb = methodSize * methodSize * frameSize / (1024 * 1024)
-            return totalFramesSizeMb < MEMORY_LIMIT_BY_METHOD_MB
+            val methodSize = node.instructions.size()
+            if (node.tryCatchBlocks.size > TRY_CATCH_BLOCKS_SOFT_LIMIT) {
+                if (getTotalFramesWeight(getTotalTcbSize(node) * methodSize, node) > MEMORY_LIMIT_BY_METHOD_MB)
+                    return false
+            }
+            return getTotalFramesWeight(methodSize * methodSize, node) < MEMORY_LIMIT_BY_METHOD_MB
         }
+
+        private fun getTotalFramesWeight(size: Int, node: MethodNode) =
+            size.toLong() * (node.maxLocals + node.maxStack) / (1024 * 1024)
+
+        private fun getTotalTcbSize(node: MethodNode) =
+            node.tryCatchBlocks.sumOf { node.instructions.indexOf(it.end) - node.instructions.indexOf(it.start) }
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxedBasicValue.kt

@@ -56,7 +56,7 @@ class TaintedBoxedValue(private val boxedBasicValue: CleanBoxedValue) : BoxedBas
 
 
 class BoxedValueDescriptor(
-    private val boxedType: Type,
+    boxedType: Type,
     val boxingInsn: AbstractInsnNode,
     val progressionIterator: ProgressionIteratorBasicValue?,
     val generationState: GenerationState

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingMethodTransformer.kt

@@ -38,6 +38,10 @@ import java.util.*
 class RedundantBoxingMethodTransformer(private val generationState: GenerationState) : MethodTransformer() {
 
     override fun transform(internalClassName: String, node: MethodNode) {
+        val insns = node.instructions.toArray()
+        if (insns.none { it.isBoxing(generationState) || it.isMethodInsnWith(Opcodes.INVOKEINTERFACE) { name == "next" } })
+            return
+
         val interpreter = RedundantBoxingInterpreter(node.instructions, generationState)
         val frames = analyze(internalClassName, node, interpreter)
 

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/FastMethodAnalyzer.kt

@@ -45,7 +45,7 @@ import org.jetbrains.org.objectweb.asm.tree.analysis.Interpreter
 import org.jetbrains.org.objectweb.asm.tree.analysis.Value
 
 /**
- * @see org.jetbrains.kotlin.codegen.optimization.fixStack.HackedFixStackMethodAnalyzerBase
+ * @see org.jetbrains.kotlin.codegen.optimization.fixStack.FastStackAnalyzer
  */
 @Suppress("DuplicatedCode")
 open class FastMethodAnalyzer<V : Value>(

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FastStackAnalyzer.kt

@@ -46,7 +46,7 @@ import org.jetbrains.org.objectweb.asm.tree.analysis.Value
  * @see org.jetbrains.kotlin.codegen.optimization.common.FastMethodAnalyzer
  */
 @Suppress("DuplicatedCode")
-internal open class HackedFixStackMethodAnalyzerBase<V : Value>(
+internal open class FastStackAnalyzer<V : Value>(
     private val owner: String,
     val method: MethodNode,
     protected val interpreter: Interpreter<V>
@@ -61,8 +61,6 @@ internal open class HackedFixStackMethodAnalyzerBase<V : Value>(
     private val queue = IntArray(nInsns)
     private var top = 0
 
-    private val singlePredBlock = IntArray(nInsns)
-
     protected open fun newFrame(nLocals: Int, nStack: Int): Frame<V> = Frame(nLocals, nStack)
 
     protected open fun visitControlFlowEdge(insn: Int, successor: Int): Boolean = true
@@ -79,8 +77,6 @@ internal open class HackedFixStackMethodAnalyzerBase<V : Value>(
 
         computeExceptionEdges()
 
-        initSinglePredBlocks()
-
         val current = newFrame(method.maxLocals, method.maxStack)
         val handler = newFrame(method.maxLocals, method.maxStack)
         initControlFlowAnalysis(current, method, owner)
@@ -98,7 +94,11 @@ internal open class HackedFixStackMethodAnalyzerBase<V : Value>(
                 if (insnType == AbstractInsnNode.LABEL || insnType == AbstractInsnNode.LINE || insnType == AbstractInsnNode.FRAME) {
                     visitNopInsn(f, insn)
                 } else {
-                    current.init(f).execute(insnNode, interpreter)
+                    current.init(f)
+                    if (insnOpcode != Opcodes.RETURN) {
+                        // Don't care about possibly incompatible return type
+                        current.execute(insnNode, interpreter)
+                    }
 
                     when {
                         insnNode is JumpInsnNode ->
@@ -136,85 +136,6 @@ internal open class HackedFixStackMethodAnalyzerBase<V : Value>(
         return frames
     }
 
-    private fun initSinglePredBlocks() {
-        markSinglePredBlockEntries()
-        markSinglePredBlockBodies()
-    }
-
-    private fun markSinglePredBlockEntries() {
-        // Method entry point is SPB entry point.
-        var blockId = 0
-        singlePredBlock[0] = ++blockId
-
-        // Every jump target is SPB entry point.
-        for (insn in insnsArray) {
-            when (insn) {
-                is JumpInsnNode -> {
-                    val labelIndex = insn.label.indexOf()
-                    if (singlePredBlock[labelIndex] == 0) {
-                        singlePredBlock[labelIndex] = ++blockId
-                    }
-                }
-                is LookupSwitchInsnNode -> {
-                    insn.dflt?.let { dfltLabel ->
-                        val dfltIndex = dfltLabel.indexOf()
-                        if (singlePredBlock[dfltIndex] == 0) {
-                            singlePredBlock[dfltIndex] = ++blockId
-                        }
-                    }
-                    for (label in insn.labels) {
-                        val labelIndex = label.indexOf()
-                        if (singlePredBlock[labelIndex] == 0) {
-                            singlePredBlock[labelIndex] = ++blockId
-                        }
-                    }
-                }
-                is TableSwitchInsnNode -> {
-                    insn.dflt?.let { dfltLabel ->
-                        val dfltIndex = dfltLabel.indexOf()
-                        if (singlePredBlock[dfltIndex] == 0) {
-                            singlePredBlock[dfltIndex] = ++blockId
-                        }
-                    }
-                    for (label in insn.labels) {
-                        val labelIndex = label.indexOf()
-                        if (singlePredBlock[labelIndex] == 0) {
-                            singlePredBlock[labelIndex] = ++blockId
-                        }
-                    }
-                }
-            }
-        }
-
-        // Every try-catch block handler entry point is SPB entry point
-        for (tcb in method.tryCatchBlocks) {
-            val handlerIndex = tcb.handler.indexOf()
-            if (singlePredBlock[handlerIndex] == 0) {
-                singlePredBlock[handlerIndex] = ++blockId
-            }
-        }
-    }
-
-    private fun markSinglePredBlockBodies() {
-        var current = 0
-        for ((i, insn) in insnsArray.withIndex()) {
-            if (singlePredBlock[i] == 0) {
-                singlePredBlock[i] = current
-            } else {
-                // Entered a new SPB.
-                current = singlePredBlock[i]
-            }
-
-            // GOTO, ATHROW, *RETURN instructions terminate current SPB.
-            when (insn.opcode) {
-                Opcodes.GOTO,
-                Opcodes.ATHROW,
-                in Opcodes.IRETURN..Opcodes.RETURN ->
-                    current = 0
-            }
-        }
-    }
-
     private fun AbstractInsnNode.indexOf() = method.instructions.indexOf(this)
 
     fun getFrame(insn: AbstractInsnNode): Frame<V>? =

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FixStackAnalyzer.kt

@@ -90,7 +90,7 @@ internal class FixStackAnalyzer(
     private val analyzer = InternalAnalyzer(owner)
 
     private inner class InternalAnalyzer(owner: String) :
-        HackedFixStackMethodAnalyzerBase<FixStackValue>(owner, method, FixStackInterpreter()) {
+        FastStackAnalyzer<FixStackValue>(owner, method, FixStackInterpreter()) {
 
         val spilledStacks = hashMapOf<AbstractInsnNode, List<FixStackValue>>()
         var maxExtraStackSize = 0; private set

license/README.md

@@ -27,7 +27,7 @@ the Kotlin IntelliJ IDEA plugin:
      - License: BSD ([license/third_party/asm_license.txt][asm])
      - Origin: Derived from ASM: a very small and fast Java bytecode manipulation framework, Copyright (c) 2000-2011 INRIA, France Telecom
 
- - Path: compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/HackedFixStackMethodAnalyzerBase.kt
+ - Path: compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/FastStackAnalyzer.kt
      - License: BSD ([license/third_party/asm_license.txt][asm])
      - Origin: Derived from ASM: a very small and fast Java bytecode manipulation framework, Copyright (c) 2000-2011 INRIA, France Telecom