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/testData/codegen/box/controlStructures/tryCatchExpression.kt

@@ -0,0 +1,68 @@
+// IGNORE_BACKEND: WASM
+
+var log = ""
+
+fun foo() {
+    try {
+        log += "1"
+        mightThrow()
+        log += "2"
+    } catch (e: Throwable) {
+        log += "3"
+        return
+    }
+
+    val t = try {
+        log += "4"
+        mightThrow2()
+        log += "5"
+    } catch (e: Throwable) {
+        log += "6"
+        return
+    }
+
+    val x = try {
+        log += "7"
+        mightThrow3()
+        log += "8"
+    } catch (e: Throwable) {
+        log += "9"
+        return
+    }
+}
+
+var throw1 = false
+var throw2 = false
+var throw3 = false
+
+fun mightThrow() {
+    if (throw1) throw Exception()
+}
+
+fun mightThrow2() {
+    if (throw2) throw Exception()
+}
+
+fun mightThrow3(): Int {
+    if (throw3) throw Exception()
+    return 42
+}
+
+fun box(): String {
+    log += "a"
+    foo()
+    throw3 = true
+    log += " b"
+    foo()
+    throw2 = true
+    log += " c"
+    foo()
+    throw1 = true
+    log += " d"
+    foo()
+
+    if (log != "a124578 b124579 c1246 d13")
+        return "Failed: $log"
+
+    return "OK"
+}

compiler/testData/codegen/box/controlStructures/tryCatchFinally.kt

@@ -0,0 +1,54 @@
+// IGNORE_BACKEND: WASM
+
+var log = ""
+
+fun foo() {
+    try {
+        log += "1"
+        mightThrow()
+        log += "2"
+    } catch (e: Throwable) {
+        log += "3"
+        "OK"
+    } finally {
+        log += "4"
+        "FINALLY"
+    }
+
+    val t = try {
+        log += "5"
+        mightThrow2()
+        log += "6"
+    } catch (e: Throwable) {
+        log += "7"
+        "OK2"
+    } finally {
+        log += "8"
+        "FINALLY2"
+    }
+}
+
+var throw1 = false
+var throw2 = false
+
+fun mightThrow() {
+    if (throw1) throw Exception()
+}
+
+fun mightThrow2() {
+    if (throw2) throw Exception()
+}
+
+fun box(): String {
+    log += "a"
+    foo()
+    throw2 = true
+    log += " b"
+    foo()
+    throw1 = true
+    log += " c"
+    foo()
+    if (log != "a124568 b124578 c134578")
+        return "Failed: $log"
+    return "OK"
+}

compiler/testData/codegen/box/controlStructures/tryFinally.kt

@@ -0,0 +1,56 @@
+// IGNORE_BACKEND: WASM
+
+var log = ""
+
+fun foo() {
+    try {
+        log += "1"
+        mightThrow()
+        log += "2"
+    } finally {
+        log += "3"
+        "FINALLY"
+    }
+
+    val t = try {
+        log += "4"
+        mightThrow2()
+        log += "5"
+    } finally {
+        log += "6"
+        "FINALLY2"
+    }
+}
+
+var throw1 = false
+var throw2 = false
+
+fun mightThrow() {
+    if (throw1) throw Exception()
+}
+
+fun mightThrow2() {
+    if (throw2) throw Exception()
+}
+
+fun test() {
+    log += "a"
+    foo()
+    throw2 = true
+    log += " b"
+    foo()
+    // Never gets here.
+    throw1 = true
+    log += " c"
+    foo()
+}
+
+
+fun box(): String {
+    try {
+        test()
+    } catch (e: Exception) {}
+    if (log != "a123456 b12346")
+        return "Failed: $log"
+    return "OK"
+}