JVM remove dead code during constant condition elimination

This avoids an extra call to 'analyze', which is rather costly.

Update debugger testData: Constant condition
elimination now performs DCE more consistently.

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

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.codegen.optimization
 import org.jetbrains.kotlin.codegen.inline.insnText
 import org.jetbrains.kotlin.codegen.optimization.common.OptimizationBasicInterpreter
 import org.jetbrains.kotlin.codegen.optimization.common.StrictBasicValue
+import org.jetbrains.kotlin.codegen.optimization.common.removeAll
 import org.jetbrains.kotlin.codegen.optimization.fixStack.peek
 import org.jetbrains.kotlin.codegen.optimization.fixStack.top
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
@@ -31,12 +32,10 @@ import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
 
 class ConstantConditionEliminationMethodTransformer : MethodTransformer() {
-    private val deadCodeElimination = DeadCodeEliminationMethodTransformer()
 
     override fun transform(internalClassName: String, methodNode: MethodNode) {
         do {
             val changes = ConstantConditionsOptimization(internalClassName, methodNode).run()
-            if (changes) deadCodeElimination.transform(internalClassName, methodNode)
         } while (changes)
     }
 
@@ -49,11 +48,21 @@ class ConstantConditionEliminationMethodTransformer : MethodTransformer() {
 
         private fun collectRewriteActions(): List<() -> Unit> =
             arrayListOf<() -> Unit>().also { actions ->
+                val deadCode = ArrayList<AbstractInsnNode>()
+
                 val frames = analyze(internalClassName, methodNode, ConstantPropagationInterpreter())
                 val insns = methodNode.instructions.toArray()
+
                 for (i in frames.indices) {
-                    val frame = frames[i] ?: continue
-                    val insn = insns[i] as? JumpInsnNode ?: continue
+                    val insn = insns[i]
+                    val frame = frames[i]
+
+                    if (frame == null && insn !is LabelNode) {
+                        deadCode.add(insn)
+                        continue
+                    }
+
+                    if (insn !is JumpInsnNode) continue
                     when (insn.opcode) {
                         in Opcodes.IFEQ..Opcodes.IFLE ->
                             tryRewriteComparisonWithZero(insn, frame, actions)
@@ -61,6 +70,12 @@ class ConstantConditionEliminationMethodTransformer : MethodTransformer() {
                             tryRewriteBinaryComparison(insn, frame, actions)
                     }
                 }
+
+                if (deadCode.isNotEmpty()) {
+                    actions.add {
+                        methodNode.instructions.removeAll(deadCode)
+                    }
+                }
             }
 
         private fun tryRewriteComparisonWithZero(insn: JumpInsnNode, frame: Frame<BasicValue>, actions: ArrayList<() -> Unit>) {