JVM_IR generate range-based loop closer to Java counter loop

KT-48435 KT-48507

compiler/testData/codegen/bytecodeText/forLoop/forInArrayWithIndex/forInArrayWithIndexNoElementVar.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val arr = arrayOf("a", "b", "c", "d")
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInArrayWithIndex/forInArrayWithIndexNoIndexVar.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val arr = arrayOf("a", "b", "c", "d")
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInArrayWithIndex/forInEmptyArrayWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val arr = intArrayOf()
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInArrayWithIndex/forInIntArrayWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val arr = intArrayOf(10, 20, 30, 40)
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInArrayWithIndex/forInObjectArrayWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val arr = arrayOf("a", "b", "c", "d")
 
 fun box(): String {

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

@@ -1,3 +1,12 @@
+// 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.
+
 fun test() {
     var s = ""
     for (c in "testString") {

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

@@ -1,3 +1,12 @@
+// 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.
+
 fun <T : CharSequence> test(sequence: T) {
     var s = ""
     for (c in sequence) {

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

@@ -1,4 +1,14 @@
 // 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.
+
 val cs: CharSequence = "abcd"
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInCharSequenceWithIndex/forInEmptyStringWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 fun box(): String {
     for ((index, x) in "".withIndex()) {
         return "Loop over empty String should not be executed"

compiler/testData/codegen/bytecodeText/forLoop/forInCharSequenceWithIndex/forInStringWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 fun box(): String {
     val s = StringBuilder()
 

compiler/testData/codegen/bytecodeText/forLoop/forInCharSequenceWithIndex/forInStringWithIndexNoElementVar.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val xs = "abcd"
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInCharSequenceWithIndex/forInStringWithIndexNoIndexVar.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val xs = "abcd"
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInCharSequenceWithIndex/forInStringWithIndexWithExplicitlyTypedIndexVariable.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val xs = "abcd"
 
 fun useAny(x: Any) {}

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

@@ -1,3 +1,12 @@
+// 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 = Char.MIN_VALUE
 
 fun f(a: Char): Int {

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

@@ -1,3 +1,12 @@
+// 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 = Int.MIN_VALUE
 
 fun f(a: Int): Int {

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

@@ -1,3 +1,12 @@
+// 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 = Long.MIN_VALUE
 
 fun f(a: Long): Int {

compiler/testData/codegen/bytecodeText/forLoop/forInIndices/forInArrayListIndices.kt

@@ -1,5 +1,14 @@
 // WITH_RUNTIME
 
+// 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.
+
 fun box(): String {
     val a = ArrayList<String>()
     a.add("OK")

compiler/testData/codegen/bytecodeText/forLoop/forInIndices/forInCharSequenceIndices.kt

@@ -1,3 +1,12 @@
+// 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.
+
 fun test(s: CharSequence): Int {
     var result = 0
     for (i in s.indices) {

compiler/testData/codegen/bytecodeText/forLoop/forInIndices/forInCharSequenceTypeParameterIndices.kt

@@ -1,3 +1,12 @@
+// 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.
+
 fun <T : CharSequence> test(s: T): Int {
     var result = 0
     for (i in s.indices) {

compiler/testData/codegen/bytecodeText/forLoop/forInIndices/forInCollectionImplicitReceiverIndices.kt

@@ -1,3 +1,12 @@
+// 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.
+
 fun Collection<Int>.sumIndices(): Int {
     var sum = 0
     for (i in indices) {

compiler/testData/codegen/bytecodeText/forLoop/forInIndices/forInCollectionIndices.kt

@@ -1,3 +1,12 @@
+// 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.
+
 fun test() {
     var sum = 0
     for (i in listOf(0, 0, 0, 0).indices) {

compiler/testData/codegen/bytecodeText/forLoop/forInIndices/forInCollectionTypeParameterIndices.kt

@@ -1,3 +1,12 @@
+// 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.
+
 fun <T : Collection<*>> test(c: T) {
     var sum = 0
     for (i in c.indices) {

compiler/testData/codegen/bytecodeText/forLoop/forInIndices/forInNonOptimizedIndices.kt

@@ -1,3 +1,12 @@
+// 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.
+
 import kotlin.test.assertEquals
 
 fun test(coll: Collection<*>?): Int {

compiler/testData/codegen/bytecodeText/forLoop/forInIndices/forInObjectArrayIndices.kt

@@ -1,3 +1,12 @@
+// 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.
+
 fun test() {
     var sum = 0
     for (i in arrayOf("", "", "", "").indices) {

compiler/testData/codegen/bytecodeText/forLoop/forInIndices/forInPrimitiveArrayIndices.kt

@@ -1,3 +1,12 @@
+// 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.
+
 fun test() {
     var sum = 0
     for (i in intArrayOf(0, 0, 0, 0).indices) {

compiler/testData/codegen/bytecodeText/forLoop/forInIterableWithIndex/forInEmptyListWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val xs = listOf<Any>()
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInIterableWithIndex/forInIterableTypeParameterWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 fun <T : Iterable<*>> test(iterable: T): String {
     val s = StringBuilder()
 

compiler/testData/codegen/bytecodeText/forLoop/forInIterableWithIndex/forInListWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val xs = listOf("a", "b", "c", "d")
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInIterableWithIndex/forInListWithIndexNoElementVar.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val xs = listOf("a", "b", "c", "d")
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInIterableWithIndex/forInListWithIndexNoIndexVar.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val xs = listOf("a", "b", "c", "d")
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInIterableWithIndex/forInListWithIndexWithExplicitlyTypedIndexVariable.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val xs = listOf("a", "b", "c", "d")
 
 fun useAny(x: Any) {}

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

@@ -1,3 +1,12 @@
+// 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.
+
 fun array() = arrayOfNulls<Any>(4)
 
 fun f(): Int {

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

@@ -1,3 +1,12 @@
+// 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.
+
 fun intArray() = intArrayOf(0, 0, 0, 0)
 fun longArray() = longArrayOf(0, 0, 0, 0)
 

compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex/forInDownToWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 fun box(): String {
     for ((i, v) in (7 downTo 4).withIndex()) {
     }

compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex/forInIndicesWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 fun box(): String {
     for ((i, v) in listOf(4, 5, 6, 7).indices.withIndex()) {
     }

compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex/forInRangeToWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 fun box(): String {
     for ((i, v) in (4..7).withIndex()) {
     }

compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex/forInReversedStepWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 fun box(): String {
     for ((i, v) in ((4..11).reversed() step 2).withIndex()) {
     }

compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex/forInReversedWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 fun box(): String {
     for ((i, v) in (4..7).reversed().withIndex()) {
     }

compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex/forInStepReversedWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 fun box(): String {
     for ((i, v) in (4..11 step 2).reversed().withIndex()) {
     }

compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex/forInStepWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 fun box(): String {
     for ((i, v) in (4..11 step 2).withIndex()) {
     }

compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex/forInUntilWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 fun box(): String {
     for ((i, v) in (4 until 8).withIndex()) {
     }

compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex/forInWithIndexNoIndexOrElementVar.kt

@@ -1,4 +1,14 @@
 // 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.
+
 fun box(): String {
     for ((_, _) in (4..7).withIndex()) {
     }

compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex/forInWithIndexNotDestructured.kt

@@ -1,3 +1,12 @@
+// 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.
+
 fun box(): String {
     for (iv in (4..7).withIndex()) {
     }

compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex/forInWithIndexReversed.kt

@@ -1,3 +1,12 @@
+// 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.
+
 fun box(): String {
     for ((i, v) in (4..7).withIndex().reversed()) {
     }

compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex/forInWithIndexWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 fun box(): String {
     for ((outer, iv) in (4..7).withIndex().withIndex()) {
     }

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

@@ -23,5 +23,10 @@ fun test(): Int {
 
 // JVM_IR_TEMPLATES
 // 1 IF_ICMPGT
-// 1 IF_ICMPNE
+// 1 IF_ICMPEQ
 // 2 IF
+// 7 ILOAD
+// 4 ISTORE
+// 1 IINC
+// 1 IADD
+// 1 ISUB

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

@@ -1,3 +1,12 @@
+// 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 N = 'Z'
 
 fun test(): Int {

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

@@ -1,3 +1,12 @@
+// 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 = Char.MAX_VALUE
 
 fun f(a: Char): Int {

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

@@ -18,7 +18,13 @@ fun test(): Int {
 // JVM_TEMPLATES
 // 1 IF_ICMPGT
 // 1 IF
+// 5 ILOAD
+// 4 ISTORE
+// 1 IINC
 
 // JVM_IR_TEMPLATES
 // 1 IF_ICMPGE
-// 1 IF
+// 1 IF
+// 4 ILOAD
+// 3 ISTORE
+// 1 IINC

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

@@ -1,3 +1,12 @@
+// 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 = Int.MAX_VALUE
 
 fun f(a: Int): Int {

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

@@ -1,3 +1,12 @@
+// 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 N = 42L
 
 fun test(): Long {

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

@@ -1,3 +1,12 @@
+// 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 = Long.MAX_VALUE
 
 fun f(a: Long): Int {

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

@@ -1,3 +1,12 @@
+// 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.
+
 object Host {
     const val M = 1
     const val N = 4

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

@@ -1,3 +1,12 @@
+// 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.
+
 fun Int.digitsUpto(end: Int): Int {
     var sum = 0
     for (i in rangeTo(end)) {

compiler/testData/codegen/bytecodeText/forLoop/forInReversed/ForInReversedReversedRange.kt

@@ -1,3 +1,12 @@
+// 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.
+
 import kotlin.test.*
 
 fun intRange() = 1 .. 4

compiler/testData/codegen/bytecodeText/forLoop/forInReversed/forInReversedArrayIndices.kt

@@ -1,3 +1,12 @@
+// 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.
+
 import kotlin.test.*
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInReversed/forInReversedCharSequenceIndices.kt

@@ -1,3 +1,12 @@
+// 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.
+
 import kotlin.test.*
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInReversed/forInReversedCollectionIndices.kt

@@ -1,3 +1,12 @@
+// 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.
+
 import kotlin.test.*
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInReversed/forInReversedDownTo.kt

@@ -1,3 +1,12 @@
+// 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.
+
 import kotlin.test.*
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInReversed/forInReversedEmptyRangeLiteral.kt

@@ -1,3 +1,12 @@
+// 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.
+
 fun box(): String {
     for (i in (4 .. 1).reversed()) {
         throw AssertionError("Loop should not be executed")

compiler/testData/codegen/bytecodeText/forLoop/forInReversed/forInReversedRange.kt

@@ -1,3 +1,12 @@
+// 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.
+
 import kotlin.test.*
 
 fun intRange() = 1 .. 4

compiler/testData/codegen/bytecodeText/forLoop/forInReversed/forInReversedRangeLiteral.kt

@@ -1,3 +1,12 @@
+// 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.
+
 import kotlin.test.*
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInReversed/forInReversedReversedArrayIndices.kt

@@ -1,3 +1,12 @@
+// 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.
+
 import kotlin.test.*
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInReversed/forInReversedReversedDownTo.kt

@@ -1,3 +1,12 @@
+// 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.
+
 import kotlin.test.*
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInReversed/forInReversedReversedReversedRange.kt

@@ -1,3 +1,12 @@
+// 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.
+
 import kotlin.test.*
 
 fun intRange() = 1 .. 4

compiler/testData/codegen/bytecodeText/forLoop/forInReversed/forInReversedReversedUntil.kt

@@ -1,3 +1,12 @@
+// 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.
+
 import kotlin.test.*
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInReversed/forInReversedUntil.kt

@@ -1,3 +1,12 @@
+// 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.
+
 import kotlin.test.*
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInSequenceWithIndex/forInEmptySequenceWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val xs = listOf<Any>().asSequence()
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInSequenceWithIndex/forInSequenceTypeParameterWithIndex.kt

@@ -1,4 +1,14 @@
 // 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.
+
 fun <T : Sequence<*>> test(sequence: T): String {
     val s = StringBuilder()
 

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

@@ -1,4 +1,14 @@
 // 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.
+
 val xs = listOf("a", "b", "c", "d").asSequence()
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInSequenceWithIndex/forInSequenceWithIndexNoElementVar.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val xs = listOf("a", "b", "c", "d").asSequence()
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInSequenceWithIndex/forInSequenceWithIndexNoIndexVar.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val xs = listOf("a", "b", "c", "d").asSequence()
 
 fun box(): String {

compiler/testData/codegen/bytecodeText/forLoop/forInSequenceWithIndex/forInSequenceWithIndexThrowsCME.kt

@@ -1,6 +1,15 @@
 // IGNORE_BACKEND_FIR: JVM_IR
 // FULL_JDK
 
+// 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.
+
 val xsl = arrayListOf("a", "b", "c", "d")
 val xs = xsl.asSequence()
 

compiler/testData/codegen/bytecodeText/forLoop/forInSequenceWithIndex/forInSequenceWithIndexWithExplicitlyTypedIndexVariable.kt

@@ -1,4 +1,14 @@
 // 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.
+
 val xs = listOf("a", "b", "c", "d").asSequence()
 
 fun useAny(x: Any) {}

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

@@ -1,3 +1,12 @@
+// 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.
+
 fun test() {
     var s = ""
     for (c in "testString") {

compiler/testData/codegen/bytecodeText/forLoop/forInUntil/forInUntilChar.kt

@@ -1,3 +1,12 @@
+// 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.
+
 fun test(a: Char, b: Char): String {
     var s = ""
     for (i in a until b) {

compiler/testData/codegen/bytecodeText/forLoop/forInUntil/forInUntilCharMaxValue.kt

@@ -1,3 +1,12 @@
+// 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 = Char.MAX_VALUE
 
 fun f(a: Char): Int {

compiler/testData/codegen/bytecodeText/forLoop/forInUntil/forInUntilCharMinValue.kt

@@ -1,3 +1,12 @@
+// 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 = Char.MIN_VALUE
 
 fun f(a: Char): Int {

compiler/testData/codegen/bytecodeText/forLoop/forInUntil/forInUntilInt.kt

@@ -1,3 +1,12 @@
+// 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.
+
 fun test(a: Int, b: Int): Int {
     var sum = 0
     for (i in a until b) {

compiler/testData/codegen/bytecodeText/forLoop/forInUntil/forInUntilIntMaxValue.kt

@@ -1,3 +1,12 @@
+// 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 = Int.MAX_VALUE
 
 fun f(a: Int): Int {

compiler/testData/codegen/bytecodeText/forLoop/forInUntil/forInUntilIntMinValue.kt

@@ -1,3 +1,12 @@
+// 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 = Int.MIN_VALUE
 
 fun f(a: Int): Int {

compiler/testData/codegen/bytecodeText/forLoop/forInUntil/forInUntilLong.kt

@@ -1,3 +1,12 @@
+// 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.
+
 fun test(a: Long, b: Long): Long {
     var sum = 0L
     for (i in a until b) {

compiler/testData/codegen/bytecodeText/forLoop/forInUntil/forInUntilLongMaxValue.kt

@@ -1,3 +1,12 @@
+// 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 = Long.MAX_VALUE
 
 fun f(a: Long): Int {

compiler/testData/codegen/bytecodeText/forLoop/forInUntil/forInUntilLongMinValue.kt

@@ -1,3 +1,12 @@
+// 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 = Long.MIN_VALUE
 
 fun f(a: Long): Int {

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

@@ -1,3 +1,12 @@
+// 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.
+
 fun test(): Int {
     var sum = 0
     for (i in 4 downTo 1) {

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

@@ -1,3 +1,12 @@
+// 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.
+
 // WITH_RUNTIME
 
 fun intRangeTo(a: Int, b: Int) { for (i in a .. b) {} }

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

@@ -1,3 +1,12 @@
+// 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.
+
 fun Int.toTrue() = true
 
 fun testBooleanArray(n: Int) =

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

@@ -1,3 +1,12 @@
+// 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.
+
 fun f() {
     for (c in "123") {
         print(c)

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

@@ -1,3 +1,12 @@
+// 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.
+
 fun f() {
     for (i in 1..2) {
     }

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

@@ -1,3 +1,12 @@
+// 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.
+
 fun f(a: Int, b: Int) {
     for (i in a..b) {
     }

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

@@ -1,3 +1,12 @@
+// 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.
+
 fun f() {
     for (i in 0..5 step 2) {
     }
@@ -11,36 +20,6 @@ fun f() {
 // JVM non-IR does NOT specifically handle "step" progressions. The stepped progressions in the above code are constructed and their
 // first/last/step properties are retrieved.
 // JVM IR has an optimized handler for "step" progressions and elides the construction of the stepped progressions.
-//
-// Expected lowered form of `for (i in 0..5 step 2)`:
-//
-//   // Standard form of loop over progression
-//   var inductionVar = 0
-//   val last = getProgressionLastElement(0, 5, 2)
-//   val step = 2
-//   if (inductionVar <= last) {
-//     // Loop is not empty
-//     do {
-//       val i = inductionVar
-//       inductionVar += step
-//       // Loop body
-//     } while (i != last)
-//   }
-//
-// Expected lowered form of `for (i in 5 downTo 1 step 1)`:
-//
-//   // Standard form of loop over progression
-//   var inductionVar = 5
-//   val last = 1
-//   val step = -1
-//   if (last <= inductionVar) {   // Optimized out in bytecode
-//     // Loop is not empty
-//     do {
-//       val i = inductionVar
-//       inductionVar += step
-//       // Loop body
-//     } while (last <= inductionVar)
-//   }
 
 // 0 iterator
 
@@ -56,7 +35,12 @@ fun f() {
 // 0 getLast
 // 0 getStep
 // 1 IF_ICMPGT
-// 1 IF_ICMPNE
+// 1 IF_ICMPEQ
 // 1 IF_ICMPLE
 // 3 IF
-// 1 INVOKESTATIC kotlin/internal/ProgressionUtilKt.getProgressionLastElement \(III\)I
+// 1 INVOKESTATIC kotlin/internal/ProgressionUtilKt.getProgressionLastElement \(III\)I
+// 6 ILOAD
+// 4 ISTORE
+// 2 IINC
+// 0 IADD
+// 0 ISUB

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

@@ -1,5 +1,17 @@
+// 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.
+
+fun consume(i: Int) {}
+
 fun f(r: IntRange) {
     for (i in r) {
+        consume(i)
     }
 }
 
@@ -8,4 +20,11 @@ fun f(r: IntRange) {
 // 0 getEnd
 // 1 getFirst
 // 1 getLast
-// 0 getStep
+// 0 getStep
+
+// 2 ISTORE
+// 5 ILOAD
+// 1 IINC
+// 1 IF_ICMPGT
+// 1 IF_ICMPEQ
+// 2 IF

compiler/testData/codegen/bytecodeText/forLoop/stepped/illegalStepConst.kt

@@ -1,4 +1,14 @@
 // TARGET_BACKEND: 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.
+
 fun box(): String {
     for (i in 1..6 step 0) {
     }
@@ -8,23 +18,6 @@ fun box(): String {
 
 // For "step" progressions in JVM IR, if the step is constant and <= 0, the expression for step is replaced with an
 // IllegalArgumentException. The backend can then eliminate the entire loop and the rest of the function as dead code.
-//
-// Expected lowered form of loop (before bytecode optimization):
-//
-//   // Additional statements:
-//   throw IllegalArgumentException("Step must be positive, was: 0.")
-//
-//   // Standard form of loop over progression
-//   var inductionVar = 1
-//   val last = getProgressionLastElement(1, 6, 0)
-//   if (inductionVar <= last) {
-//     // Loop is not empty
-//     do {
-//       val i = inductionVar
-//       inductionVar += 0
-//       // Loop body
-//     } while (i != last)
-//   }
 
 // 0 iterator
 // 0 getStart

compiler/testData/codegen/bytecodeText/forLoop/stepped/reversedThenStep.kt

@@ -1,4 +1,14 @@
 // TARGET_BACKEND: 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.
+
 fun box(): String {
     for (i in (1..8).reversed() step 2) {
     }
@@ -9,22 +19,6 @@ fun box(): String {
 // For "step" progressions in JVM IR, a call to getProgressionLastElement() is made to compute the "last" value.
 // If the step is non-constant, there is a check that it is > 0, and if not, an IllegalArgumentException is thrown. However, when the
 // step is constant and > 0, this check does not need to be added.
-//
-// Expected lowered form of loop:
-//
-//   // Standard form of loop over progression
-//   val last = getProgressionLastElement(8, 1, -2)
-//   var inductionVar = 8
-//   if (last <= inductionVar) {
-//     // Loop is not empty
-//     do {
-//       val i = inductionVar
-//       inductionVar += -2
-//       // Loop body
-//     } while (i != last)
-//   }
-//
-// We can't use "0 reversed" in the regex below because "reversed" is in the test filename.
 
 // 0 INVOKE.*reversed
 // 0 iterator
@@ -37,5 +31,11 @@ fun box(): String {
 // 0 NEW java/lang/IllegalArgumentException
 // 0 ATHROW
 // 1 IF_ICMPGT
-// 1 IF_ICMPNE
-// 2 IF
+// 1 IF_ICMPEQ
+// 2 IF
+// 4 ILOAD
+// 2 ISTORE
+// 0 IADD
+// 0 ISUB
+// 1 IINC
+// 1 IINC

compiler/testData/codegen/bytecodeText/forLoop/stepped/stepConst.kt

@@ -1,4 +1,14 @@
 // TARGET_BACKEND: 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.
+
 fun box(): String {
     for (i in 1..7 step 2) {
     }
@@ -9,20 +19,6 @@ fun box(): String {
 // For "step" progressions in JVM IR, a call to getProgressionLastElement() is made to compute the "last" value.
 // If the step is non-constant, there is a check that it is > 0, and if not, an IllegalArgumentException is thrown. However, when the
 // step is constant and > 0, this check does not need to be added.
-//
-// Expected lowered form of loop:
-//
-//   // Standard form of loop over progression
-//   var inductionVar = 1
-//   val last = getProgressionLastElement(1, 7, 2)
-//   if (inductionVar <= last) {
-//     // Loop is not empty
-//     do {
-//       val i = inductionVar
-//       inductionVar += 2
-//       // Loop body
-//     } while (i != last)
-//   }
 
 // 0 iterator
 // 0 getStart
@@ -34,5 +30,10 @@ fun box(): String {
 // 0 NEW java/lang/IllegalArgumentException
 // 0 ATHROW
 // 1 IF_ICMPGT
-// 1 IF_ICMPNE
-// 2 IF
+// 1 IF_ICMPEQ
+// 2 IF
+// 4 ILOAD
+// 2 ISTORE
+// 0 IADD
+// 0 ISUB
+// 1 IINC

compiler/testData/codegen/bytecodeText/forLoop/stepped/stepConstOnNonLiteralProgression.kt

@@ -1,4 +1,14 @@
 // TARGET_BACKEND: 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.
+
 fun box(): String {
     val intProgression = 1..7 step 3  // `step` ensures type is IntProgression, NOT IntRange
     for (i in intProgression step 2) {
@@ -12,25 +22,7 @@ fun box(): String {
 // If the step is non-constant, there is a check that it is > 0, and if not, an IllegalArgumentException is thrown. However, when the
 // step is constant and > 0, this check does not need to be added.
 //
-// Expected lowered form of loop:
-//
-//   // Additional statements:
-//   val nestedFirst = intProgression.first
-//   val nestedLast = intProgression.last
-//   val nestedStep = intProgression.step
-//   val maybeNegatedStep = if (nestedStep <= 0) -2 else 2
-//
-//   // Standard form of loop over progression
-//   var inductionVar = nestedFirst
-//   val last = getProgressionLastElement(nestedFirst, nestedLast, maybeNegatedStep)
-//   if ((maybeNegatedStep > 0 && inductionVar <= last) || (maybeNegatedStep < 0 && last <= inductionVar)) {
-//     // Loop is not empty
-//     do {
-//       val i = inductionVar
-//       inductionVar += maybeNegatedStep
-//       // Loop body
-//     } while (i != last)
-//   }
+
 
 // 0 iterator
 // 0 getStart
@@ -43,9 +35,14 @@ fun box(): String {
 // 0 ATHROW
 // 1 IF_ICMPGT
 // 1 IF_ICMPLE
-// 1 IF_ICMPNE
+// 1 IF_ICMPEQ
 // 1 IFLE
 // 1 IFGT
 // 1 IFGE
 // 6 IF
-// 0 INEG
+// 0 INEG
+// 14 ILOAD
+// 6 ISTORE
+// 1 IADD
+// 0 ISUB
+// 0 IINC

compiler/testData/codegen/bytecodeText/forLoop/stepped/stepNonConst.kt

@@ -1,4 +1,14 @@
 // TARGET_BACKEND: 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.
+
 fun one() = 1
 
 fun box(): String {
@@ -11,23 +21,6 @@ fun box(): String {
 // For "step" progressions in JVM IR, a call to getProgressionLastElement() is made to compute the "last" value.
 // If the step is non-constant, there is a check that it is > 0, and if not, an IllegalArgumentException is thrown.
 //
-// Expected lowered form of loop:
-//
-//   // Additional statements:
-//   var stepArg = one()
-//   if (stepArg <= 0) throw IllegalArgumentException("Step must be positive, was: $stepArg.")
-//
-//   // Standard form of loop over progression
-//   var inductionVar = 1
-//   val last = getProgressionLastElement(1, 7, stepArg)
-//   if (inductionVar <= last) {
-//     // Loop is not empty
-//     do {
-//       val i = inductionVar
-//       inductionVar += stepArg
-//       // Loop body
-//     } while (i != last)
-//   }
 
 // 0 iterator
 // 0 getStart
@@ -39,6 +32,11 @@ fun box(): String {
 // 1 NEW java/lang/IllegalArgumentException
 // 1 ATHROW
 // 1 IF_ICMPGT
-// 1 IF_ICMPNE
+// 1 IF_ICMPEQ
 // 1 IFGT
-// 3 IF
+// 3 IF
+// 9 ILOAD
+// 4 ISTORE
+// 1 IADD
+// 0 ISUB
+// 0 IINC

compiler/testData/codegen/bytecodeText/forLoop/stepped/stepNonConstOnNonLiteralProgression.kt

@@ -1,4 +1,14 @@
 // TARGET_BACKEND: 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.
+
 fun one() = 1
 
 fun box(): String {
@@ -13,27 +23,7 @@ fun box(): String {
 // If "step" is called on a non-literal progression, there is a check to see if that progression's step value is < 0.
 // If the step is non-constant, there is a check that it is > 0, and if not, an IllegalArgumentException is thrown.
 //
-// Expected lowered form of loop:
-//
-//   // Additional statements:
-//   val nestedFirst = intProgression.first
-//   val nestedLast = intProgression.last
-//   val nestedStep = intProgression.step
-//   var stepArg = one()
-//   if (stepArg <= 0) throw IllegalArgumentException("Step must be positive, was: $stepArg.")
-//   if (nestedStep <= 0) stepArg = -stepArg
-//
-//   // Standard form of loop over progression
-//   var inductionVar = nestedFirst
-//   val last = getProgressionLastElement(nestedFirst, nestedLast, stepArg)
-//   if ((stepArg > 0 && inductionVar <= last) || (stepArg < 0 && last <= inductionVar)) {
-//     // Loop is not empty
-//     do {
-//       val i = inductionVar
-//       inductionVar += stepArg
-//       // Loop body
-//     } while (i != last)
-//   }
+
 
 // 0 iterator
 // 0 getStart
@@ -46,9 +36,14 @@ fun box(): String {
 // 1 ATHROW
 // 1 IF_ICMPGT
 // 1 IF_ICMPLE
-// 1 IF_ICMPNE
+// 1 IF_ICMPEQ
 // 1 IFLE
 // 2 IFGT
 // 1 IFGE
 // 7 IF
-// 1 INEG
+// 1 INEG
+// 18 ILOAD
+// 8 ISTORE
+// 1 IADD
+// 0 ISUB
+// 0 IINC

compiler/testData/codegen/bytecodeText/forLoop/stepped/stepOnNonLiteralRange.kt

@@ -1,4 +1,14 @@
 // TARGET_BACKEND: 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.
+
 fun box(): String {
     val intRange = 1..7
     for (i in intRange step 2) {
@@ -12,23 +22,6 @@ fun box(): String {
 // However, if the progression is of type *Range (e.g., IntRange) instead of *Progression (e.g., IntProgression), this
 // check is not needed since *Range always has step == 1.
 //
-// Expected lowered form of loop:
-//
-//   // Additional statements:
-//   val nestedFirst = intRange.first
-//   val nestedLast = intRange.last
-//
-//   // Standard form of loop over progression
-//   var inductionVar = nestedFirst
-//   val last = getProgressionLastElement(nestedFirst, nestedLast, 2)
-//   if (inductionVar <= last) {
-//     // Loop is not empty
-//     do {
-//       val i = inductionVar
-//       inductionVar += 2
-//       // Loop body
-//     } while (i != last)
-//   }
 
 // 0 iterator
 // 0 getStart
@@ -40,6 +33,11 @@ fun box(): String {
 // 0 NEW java/lang/IllegalArgumentException
 // 0 ATHROW
 // 1 IF_ICMPGT
-// 1 IF_ICMPNE
+// 1 IF_ICMPEQ
 // 2 IF
-// 0 INEG
+// 0 INEG
+// 7 ILOAD
+// 4 ISTORE
+// 0 IADD
+// 0 ISUB
+// 1 IINC

compiler/testData/codegen/bytecodeText/forLoop/stepped/stepOne.kt

@@ -1,4 +1,14 @@
 // TARGET_BACKEND: 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.
+
 fun box(): String {
     for (i in 1..4 step 1) {
     }