Do not restore stack in default handler for try-finally

It never terminates, so the corresponding value on stack can't be used.
However, if this happens in an inlined lambda argument, the inliner is
unable to remove the corresponding ALOAD instruction (because default
handler never terminates, and thus corresponding ALOAD is not used for
lambda invocation).

KT-17573 try-finally expression in inlined function parameter argument fails with VerifyError

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

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.codegen.optimization.fixStack
 import org.jetbrains.kotlin.codegen.optimization.common.findNextOrNull
 import org.jetbrains.kotlin.codegen.optimization.common.hasOpcode
 import org.jetbrains.kotlin.codegen.pseudoInsns.PseudoInsn
+import org.jetbrains.kotlin.utils.SmartSet
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
@@ -117,6 +118,11 @@ private fun insertSaveRestoreStackMarkers(
 private fun collectDecompiledTryDescriptors(methodNode: MethodNode): Map<LabelNode, DecompiledTryDescriptor> {
     val decompiledTryDescriptorForStart: MutableMap<LabelNode, DecompiledTryDescriptor> = hashMapOf()
     val decompiledTryDescriptorForHandler: MutableMap<LabelNode, DecompiledTryDescriptor> = hashMapOf()
+
+    val defaultHandlers = methodNode.tryCatchBlocks.mapNotNullTo(SmartSet.create()) {
+        if (it.isDefaultHandlerNode()) it.handler else null
+    }
+
     for (tcb in methodNode.tryCatchBlocks) {
         if (tcb.isDefaultHandlerNode()) {
             assert(decompiledTryDescriptorForHandler.containsKey(tcb.start)) { "${methodNode.debugString(tcb)}: default handler should occur after some regular handler" }
@@ -127,9 +133,8 @@ private fun collectDecompiledTryDescriptors(methodNode: MethodNode): Map<LabelNo
                 DecompiledTryDescriptor(tcb.start)
             }
         }
-        with(decompiledTryDescriptor) {
-            handlerStartLabels.add(tcb.handler)
 
+        with(decompiledTryDescriptor) {
             if (tcb.isDefaultHandlerNode()) {
                 assert(defaultHandlerTcb == null) {
                     "${methodNode.debugString(tcb)}: default handler is already found: ${methodNode.debugString(defaultHandlerTcb!!)}"
@@ -137,6 +142,10 @@ private fun collectDecompiledTryDescriptors(methodNode: MethodNode): Map<LabelNo
 
                 defaultHandlerTcb = tcb
             }
+
+            if (tcb.handler !in defaultHandlers) {
+                handlerStartLabels.add(tcb.handler)
+            }
         }
     }
 

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

@@ -33,14 +33,13 @@ internal class FixStackContext(val methodNode: MethodNode) {
     val fakeAlwaysFalseIfeqMarkers = arrayListOf<AbstractInsnNode>()
 
     val isThereAnyTryCatch: Boolean
-    val saveStackMarkerForRestoreMarker: Map<AbstractInsnNode, AbstractInsnNode>
+    val saveStackMarkerForRestoreMarker = insertTryCatchBlocksMarkers(methodNode)
     val restoreStackMarkersForSaveMarker = hashMapOf<AbstractInsnNode, MutableList<AbstractInsnNode>>()
 
     val openingInlineMethodMarker = hashMapOf<AbstractInsnNode, AbstractInsnNode>()
     var consistentInlineMarkers: Boolean = true; private set
 
     init {
-        saveStackMarkerForRestoreMarker = insertTryCatchBlocksMarkers(methodNode)
         isThereAnyTryCatch = saveStackMarkerForRestoreMarker.isNotEmpty()
         for ((restore, save) in saveStackMarkerForRestoreMarker) {
             restoreStackMarkersForSaveMarker.getOrPut(save) { SmartList() }.add(restore)