JVM_IR KT-48640 generate for-in-downTo as a counter loop

compiler/testData/codegen/box/ranges/forInDownTo/forInDownToWithPossibleUnderflow.kt

@@ -0,0 +1,72 @@
+// WITH_RUNTIME
+
+const val MB = Byte.MIN_VALUE
+const val MS = Short.MIN_VALUE
+const val MI = Int.MIN_VALUE
+const val ML = Long.MIN_VALUE
+const val MC = Char.MIN_VALUE
+
+fun testByte() {
+    var s = ""
+    var t = 0
+    for (i in MB + 1 downTo MB) {
+        ++t
+        s += i
+        if (t > 2) throw Exception("too many iterations: $t")
+    }
+    if (s != "-127-128") throw Exception(s)
+}
+
+fun testShort() {
+    var s = ""
+    var t = 0
+    for (i in MS + 1 downTo MS) {
+        ++t
+        s += i
+        if (t > 2) throw Exception("too many iterations: $t")
+    }
+    if (s != "-32767-32768") throw Exception(s)
+}
+
+fun testInt() {
+    var s = ""
+    var t = 0
+    for (i in MI + 1 downTo MI) {
+        ++t
+        s += i
+        if (t > 2) throw Exception("too many iterations: $t")
+    }
+    if (s != "-2147483647-2147483648") throw Exception(s)
+}
+
+fun testLong() {
+    var s = ""
+    var t = 0
+    for (i in ML + 1L downTo ML) {
+        ++t
+        s += i
+        if (t > 2) throw Exception("too many iterations: $t")
+    }
+    if (s != "-9223372036854775807-9223372036854775808") throw Exception(s)
+}
+
+fun testChar() {
+    var s = ""
+    var t = 0
+    for (i in (MC.toInt() + 1).toChar() downTo MC) {
+        ++t
+        s += i.toInt()
+        if (t > 2) throw Exception("too many iterations: $t")
+    }
+    if (s != "10") throw Exception(s)
+}
+
+fun box(): String {
+    testByte()
+    testShort()
+    testInt()
+    testLong()
+    testChar()
+
+    return "OK"
+}

compiler/testData/codegen/bytecodeText/forLoop/forInDownToLongConstNoUnderflow.kt

@@ -0,0 +1,36 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+
+// IMPORTANT!
+// Please, when your changes cause failures in bytecodeText tests for 'for' loops,
+// examine the resulting bytecode shape carefully.
+// Range and progression-based loops generated with Kotlin compiler should be
+// as close as possible to Java counter loops ('for (int i = a; i < b; ++i) { ... }').
+// Otherwise it may result in performance regression due to missing HotSpot optimizations.
+// Run Kotlin compiler benchmarks (https://github.com/Kotlin/kotlin-benchmarks)
+// with compiler built from your changes if you are not sure.
+
+const val M = 1L
+
+fun f(a: Long): Int {
+    var n = 0
+    for (i in a downTo M) {
+        n++
+    }
+    return n
+}
+
+// 0 iterator
+// 0 getStart
+// 0 getEnd
+// 0 getFirst
+// 0 getLast
+// 0 getStep
+// 1 LCMP
+// 1 IF
+
+// JVM_IR_TEMPLATES
+// 1 ILOAD
+// 1 ISTORE
+// 0 IADD
+// 0 ISUB
+// 1 IINC

compiler/testData/codegen/bytecodeText/forLoop/forIntInDownTo.kt

@@ -24,8 +24,8 @@ fun test(): Int {
 // 1 IF
 
 // JVM_IR_TEMPLATES
-// 5 ILOAD
-// 4 ISTORE
+// 4 ILOAD
+// 3 ISTORE
 // 1 IADD
 // 0 ISUB
 // 1 IINC