JVM_IR generate range-based loop closer to Java counter loop

KT-48435 KT-48507
2021-09-01 15:31:19 +03:00
parent 9ed08438d5
commit b669de1663
137 changed files with 1518 additions and 573 deletions
@@ -10093,12 +10093,6 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                runTest("compiler/testData/codegen/box/coroutines/debug/debuggerMetadata.kt");
            }

-            @Test
-            @TestMetadata("debuggerMetadata_ir.kt")
-            public void testDebuggerMetadata_ir() throws Exception {
-                runTest("compiler/testData/codegen/box/coroutines/debug/debuggerMetadata_ir.kt");
-            }
-
            @Test
            @TestMetadata("elvisLineNumber.kt")
            public void testElvisLineNumber() throws Exception {
@@ -11,9 +11,11 @@ import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.builders.IrBuilderWithScope
 import org.jetbrains.kotlin.ir.builders.irCall
 import org.jetbrains.kotlin.ir.builders.irString
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.expressions.IrCall
 import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrFileSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
@@ -53,4 +55,13 @@ interface CommonBackendContext : BackendContext, LoggingContext {

    val preferJavaLikeCounterLoop: Boolean
        get() = false
+
+    val reuseLoopVariableAsInductionVariable: Boolean
+        get() = false
+
+    val doWhileCounterLoopOrigin: IrStatementOrigin?
+        get() = null
+
+    val inductionVariableOrigin: IrDeclarationOrigin
+        get() = IrDeclarationOrigin.IR_TEMPORARY_VARIABLE
 }
@@ -47,7 +47,7 @@ abstract class AbstractVariableRemapper : IrElementTransformerVoid() {
    override fun visitSetValue(expression: IrSetValue): IrExpression {
        expression.transformChildrenVoid()
        return remapVariable(expression.symbol.owner)?.let {
-            IrSetValueImpl(expression.startOffset, expression.endOffset, it.type, it.symbol, expression.value, expression.origin)
+            IrSetValueImpl(expression.startOffset, expression.endOffset, expression.type, it.symbol, expression.value, expression.origin)
        } ?: expression
    }
 }
@@ -8,16 +8,18 @@ package org.jetbrains.kotlin.backend.common.lower.loops
 import org.jetbrains.kotlin.backend.common.BodyLoweringPass
 import org.jetbrains.kotlin.backend.common.CommonBackendContext
 import org.jetbrains.kotlin.backend.common.IrElementTransformerVoidWithContext
+import org.jetbrains.kotlin.backend.common.lower.AbstractVariableRemapper
 import org.jetbrains.kotlin.backend.common.lower.createIrBuilder
 import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
-import org.jetbrains.kotlin.ir.declarations.IrDeclaration
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrSymbolOwner
-import org.jetbrains.kotlin.ir.declarations.IrVariable
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrCompositeImpl
+import org.jetbrains.kotlin.ir.symbols.impl.IrVariableSymbolImpl
+import org.jetbrains.kotlin.ir.types.classifierOrNull
+import org.jetbrains.kotlin.ir.types.isNullable
 import org.jetbrains.kotlin.ir.util.dump
 import org.jetbrains.kotlin.ir.util.render
 import org.jetbrains.kotlin.ir.visitors.*
@@ -97,7 +99,10 @@ val forLoopsPhase = makeIrFilePhase(
 *   }
 * ```
 */
-class ForLoopsLowering(val context: CommonBackendContext, val loopBodyTransformer: ForLoopBodyTransformer? = null) : BodyLoweringPass {
+class ForLoopsLowering(
+    val context: CommonBackendContext,
+    private val loopBodyTransformer: ForLoopBodyTransformer? = null
+) : BodyLoweringPass {

    override fun lower(irBody: IrBody, container: IrDeclaration) {
        val oldLoopToNewLoop = mutableMapOf<IrLoop, IrLoop>()
@@ -160,30 +165,127 @@ private class RangeLoopTransformer(
            return super.visitBlock(expression)  // Not a for-loop block.
        }

-        with(expression.statements) {
-            assert(size == 2) { "Expected 2 statements in for-loop block, was:\n${expression.dump()}" }
-            val iteratorVariable = get(0) as IrVariable
-            assert(iteratorVariable.origin == IrDeclarationOrigin.FOR_LOOP_ITERATOR) { "Expected FOR_LOOP_ITERATOR origin for iterator variable, was:\n${iteratorVariable.dump()}" }
-            val loopHeader = headerProcessor.extractHeader(iteratorVariable)
-                ?: return super.visitBlock(expression)  // The iterable in the header is not supported.
-            val loweredHeader = lowerHeader(iteratorVariable, loopHeader)
+        val statements = expression.statements
+        assert(statements.size == 2) { "Expected 2 statements in for-loop block, was:\n${expression.dump()}" }
+        val iteratorVariable = statements[0] as IrVariable
+        assert(iteratorVariable.origin == IrDeclarationOrigin.FOR_LOOP_ITERATOR) {
+            "Expected FOR_LOOP_ITERATOR origin for iterator variable, was:\n${iteratorVariable.dump()}"
+        }
+        val oldLoop = statements[1] as IrWhileLoop
+        assert(oldLoop.origin == IrStatementOrigin.FOR_LOOP_INNER_WHILE) {
+            "Expected FOR_LOOP_INNER_WHILE origin for while loop, was:\n${oldLoop.dump()}"
+        }

-            val oldLoop = get(1) as IrWhileLoop
-            assert(oldLoop.origin == IrStatementOrigin.FOR_LOOP_INNER_WHILE) { "Expected FOR_LOOP_INNER_WHILE origin for while loop, was:\n${oldLoop.dump()}" }
-            val (newLoop, loopReplacementExpression) = lowerWhileLoop(oldLoop, loopHeader)
-                ?: return super.visitBlock(expression)  // Cannot lower the loop.
+        val loopHeader = headerProcessor.extractHeader(iteratorVariable)
+            ?: return super.visitBlock(expression)  // The iterable in the header is not supported.
+        val loweredHeader = lowerHeader(iteratorVariable, loopHeader)

-            // We can lower both the header and while loop.
-            // Update mapping from old to new loop so we can later update references in break/continue.
-            oldLoopToNewLoop[oldLoop] = newLoop
+        val (newLoop, loopReplacementExpression) = lowerWhileLoop(oldLoop, loopHeader)
+            ?: return super.visitBlock(expression)  // Cannot lower the loop.

-            set(0, loweredHeader)
-            set(1, loopReplacementExpression)
+        // We can lower both the header and while loop.
+        // Update mapping from old to new loop so we can later update references in break/continue.
+        oldLoopToNewLoop[oldLoop] = newLoop
+
+        statements[0] = loweredHeader
+        statements[1] = loopReplacementExpression
+
+        if (context.reuseLoopVariableAsInductionVariable && loopHeader.canReuseLoopVariableAsInductionVariable) {
+            reuseLoopVariableAsInductionVariable(expression)
        }

        return super.visitBlock(expression)
    }

+    private fun reuseLoopVariableAsInductionVariable(irBlock: IrBlock) {
+        // Given a loop in the form:
+        //      {
+        //          var inductionVariable = <start>
+        //      }
+        //      do {
+        //          if (!(<whileLoopCondition>)) break
+        //          val loopVariable = inductionVariable
+        //          <originalLoopBody>
+        //      } while ( { inductionVariable += <step>; true } )
+        // replace it with:
+        //      {
+        //          var loopVariable' = <start>
+        //      }
+        //      do {
+        //          if (!(<whileLoopCondition'>)) break
+        //          <originalLoopBody'>
+        //      } while ( { loopVariable' += <step>; true } )
+        // where whenLoopCondition' and originalLoopBody' are corresponding statements
+        //  with inductionVariable and loopVariable remapped to loopVariable'.
+        //
+        // NB we can do so only with a do-while counter loop as described above,
+        //  otherwise it changes semantics of 'continue' inside the loop.
+
+        val header = irBlock.statements[0] as? IrStatementContainer ?: return
+
+        val inductionVariableIndex = header.statements.indexOfFirst { it.isInductionVariable(context) }
+        if (inductionVariableIndex < 0) return
+        val inductionVariable = header.statements[inductionVariableIndex] as IrVariable
+
+        val innerLoop = findInnerDoWhileLoop(irBlock.statements[1]) ?: return
+        if (innerLoop.origin != context.doWhileCounterLoopOrigin) return
+        val loopVariableContainerAndIndex = findLoopVariable(innerLoop) ?: return
+        val (loopVariableContainer, loopVariableIndex) = loopVariableContainerAndIndex
+        val loopVariable = loopVariableContainer.statements[loopVariableIndex] as IrVariable
+
+        val inductionVariableType = inductionVariable.type
+        val loopVariableType = loopVariable.type
+        if (loopVariableType.isNullable()) return
+        if (loopVariableType.classifierOrNull != inductionVariableType.classifierOrNull) return
+
+        val newLoopVariable = IrVariableImpl(
+            loopVariable.startOffset, loopVariable.endOffset, loopVariable.origin,
+            IrVariableSymbolImpl(),
+            loopVariable.name, loopVariableType,
+            isVar = true, // NB original loop variable is 'val'
+            isConst = false, isLateinit = false
+        )
+        newLoopVariable.initializer = inductionVariable.initializer
+
+        header.statements[inductionVariableIndex] = newLoopVariable
+        loopVariableContainer.statements.removeAt(loopVariableIndex)
+
+        val remapper = object : AbstractVariableRemapper() {
+            override fun remapVariable(value: IrValueDeclaration): IrValueDeclaration? =
+                if (value == inductionVariable || value == loopVariable) newLoopVariable else null
+        }
+        irBlock.statements[1].transformChildren(remapper, null)
+    }
+
+    private fun findInnerDoWhileLoop(statement: IrStatement): IrDoWhileLoop? {
+        if (statement is IrDoWhileLoop) {
+            return statement
+        }
+        if (statement is IrWhen) {
+            val branch0Result = statement.branches[0].result
+            if (branch0Result is IrDoWhileLoop)
+                return branch0Result
+        }
+        return null
+    }
+
+    private fun findLoopVariable(doWhileLoop: IrDoWhileLoop): Pair<IrContainerExpression, Int>? {
+        val loopBody = doWhileLoop.body as? IrContainerExpression ?: return null
+        for ((index, statement) in loopBody.statements.withIndex()) {
+            if (statement.isLoopVariable())
+                return Pair(loopBody, index)
+            else if (statement is IrContainerExpression && statement.origin == IrStatementOrigin.FOR_LOOP_NEXT) {
+                val loopVarIndex = statement.statements.indexOfFirst { it.isLoopVariable() }
+                if (loopVarIndex < 0) return null
+                return Pair(statement, loopVarIndex)
+            }
+        }
+        return null
+    }
+
+    private fun IrStatement.isLoopVariable() =
+        this is IrVariable && origin == IrDeclarationOrigin.FOR_LOOP_VARIABLE
+
    /**
     * Lowers the "header" statement that stores the iterator into the loop variable
     * (e.g., `val it = someIterable.iterator()`) and gather information for building the for-loop
@@ -204,9 +306,8 @@ private class RangeLoopTransformer(

    private fun lowerWhileLoop(loop: IrWhileLoop, loopHeader: ForLoopHeader): LoopReplacement? {
        val loopBodyStatements = (loop.body as? IrContainerExpression)?.statements ?: return null
-        val (mainLoopVariable, mainLoopVariableIndex, loopVariableComponents, loopVariableComponentIndices) = gatherLoopVariableInfo(
-            loopBodyStatements
-        )
+        val (mainLoopVariable, mainLoopVariableIndex, loopVariableComponents, loopVariableComponentIndices) =
+            gatherLoopVariableInfo(loopBodyStatements)

        if (loopHeader.consumesLoopVariableComponents && mainLoopVariable.origin != IrDeclarationOrigin.IR_TEMPORARY_VARIABLE) {
            // We determine if there is a destructuring declaration by checking if the main loop variable is temporary.
@@ -44,6 +44,10 @@ interface ForLoopHeader {
     */
    val consumesLoopVariableComponents: Boolean

+    /** `true` if it's possible to use loop variable as induction variable in this kind of loop */
+    val canReuseLoopVariableAsInductionVariable: Boolean
+        get() = false
+
    /** Statements used to initialize an iteration of the loop (e.g., assign loop variable). */
    fun initializeIteration(
        loopVariable: IrVariable?,
@@ -56,6 +60,13 @@ interface ForLoopHeader {
    fun buildLoop(builder: DeclarationIrBuilder, oldLoop: IrLoop, newBody: IrExpression?): LoopReplacement
 }

+internal const val inductionVariableName = "inductionVariable"
+
+internal fun IrStatement.isInductionVariable(context: CommonBackendContext) =
+    this is IrVariable &&
+            origin == context.inductionVariableOrigin &&
+            name.asString() == inductionVariableName
+
 abstract class NumericForLoopHeader<T : NumericHeaderInfo>(
    val headerInfo: T,
    builder: DeclarationIrBuilder,
@@ -64,6 +75,8 @@ abstract class NumericForLoopHeader<T : NumericHeaderInfo>(

    override val consumesLoopVariableComponents = false

+    override val canReuseLoopVariableAsInductionVariable get() = true
+
    val inductionVariable: IrVariable

    protected val stepVariable: IrVariable?
@@ -92,8 +105,9 @@ abstract class NumericForLoopHeader<T : NumericHeaderInfo>(
                inductionVariable =
                    scope.createTmpVariable(
                        headerInfo.first.asElementType(),
-                        nameHint = "inductionVariable",
+                        nameHint = inductionVariableName,
                        isMutable = true,
+                        origin = this@NumericForLoopHeader.context.inductionVariableOrigin,
                        irType = elementClass.defaultType
                    )

@@ -317,7 +331,11 @@ class ProgressionLoopHeader(
                //       // Loop body
                //     } while (loopVar != last)
                //   }
-                val newLoop = IrDoWhileLoopImpl(oldLoop.startOffset, oldLoop.endOffset, oldLoop.type, oldLoop.origin).apply {
+                val newLoopOrigin = if (preferJavaLikeCounterLoop)
+                    this@ProgressionLoopHeader.context.doWhileCounterLoopOrigin
+                else
+                    oldLoop.origin
+                val newLoop = IrDoWhileLoopImpl(oldLoop.startOffset, oldLoop.endOffset, oldLoop.type, newLoopOrigin).apply {
                    val loopVariableExpression = irGet(loopVariable!!).let {
                        headerInfo.progressionType.run {
                            if (this is UnsignedProgressionType) {
@@ -331,6 +349,10 @@ class ProgressionLoopHeader(
                    body = newBody
                }

+                if (preferJavaLikeCounterLoop) {
+                    moveInductionVariableUpdateToLoopCondition(newLoop)
+                }
+
                val loopCondition = buildLoopCondition(this@with)
                LoopReplacement(newLoop, irIfThen(loopCondition, newLoop))
            } else if (preferJavaLikeCounterLoop && !headerInfo.isLastInclusive) {
@@ -338,25 +360,17 @@ class ProgressionLoopHeader(
                // (`for (int i = first; i < lastExclusive; ++i) { ... }`).
                // Otherwise loop-related optimizations will not kick in, resulting in significant performance degradation.
                //
-                // If possible, use a do-while loop:
+                // Use a do-while loop:
                //   do {
                //       if ( !( inductionVariable < last ) ) break
                //       val loopVariable = inductionVariable
                //       <body>
                //   } while ( { inductionVariable += step; true } )
                // This loop form is equivalent to the Java counter loop shown above.
-                //
-                // Otherwise, use a simple while loop:
-                //   while (inductionVar < last) {
-                //     val loopVar = inductionVar
-                //     inductionVar += step
-                //     // Loop body
-                //   }

                val newLoopCondition = buildLoopCondition(this@with)

                buildJavaLikeDoWhileCounterLoop(oldLoop, newLoopCondition, newBody)
-                    ?: buildJavaLikeWhileCounterLoop(oldLoop, newLoopCondition, newBody)
            } else {
                // Use an if-guarded do-while loop (note the difference in loop condition):
                //
@@ -383,11 +397,52 @@ class ProgressionLoopHeader(
            it.name == OperatorNameConventions.NOT
        } ?: error("No '${OperatorNameConventions.NOT}' in ${context.irBuiltIns.booleanClass.owner.render()}")

+    private fun moveInductionVariableUpdateToLoopCondition(doWhileLoop: IrDoWhileLoop) {
+        // On JVM, it's important that induction variable update happens in the end of the loop
+        // (otherwise HotSpot will not treat it as a counter loop).
+        // Moving induction variable update to loop condition (instead of just placing it in the end of loop body)
+        // also allows reusing loop variable as induction variable later.
+        //
+        // Transform a loop in the form:
+        //      do {
+        //          { <next> }
+        //          <body>
+        //      } while (<condition>)
+        // to
+        //      do {
+        //          { <next'> }
+        //          <body>
+        //      } while ( { if (!<condition>) break; <updateInductionVar>; true } )
+        val doWhileBody = doWhileLoop.body as? IrContainerExpression ?: return
+        if (doWhileBody.origin != IrStatementOrigin.FOR_LOOP_INNER_WHILE) return
+        val doWhileLoopNext = doWhileBody.statements[0] as? IrContainerExpression ?: return
+        if (doWhileLoopNext.origin != IrStatementOrigin.FOR_LOOP_NEXT) return
+
+        val updateInductionVarIndex = doWhileLoopNext.statements
+            .indexOfFirst { it is IrSetValue && it.symbol.owner.isInductionVariable(context) }
+        if (updateInductionVarIndex < 0) return
+        val updateInductionVar = doWhileLoopNext.statements[updateInductionVarIndex]
+        doWhileLoopNext.statements.removeAt(updateInductionVarIndex)
+
+        val loopCondition = doWhileLoop.condition
+        val loopConditionStartOffset = loopCondition.startOffset
+        val loopConditionEndOffset = loopCondition.endOffset
+        doWhileLoop.condition = IrCompositeImpl(
+            loopConditionStartOffset, loopConditionEndOffset, loopCondition.type,
+            origin = null,
+            statements = listOf(
+                createNegatedConditionCheck(doWhileLoop.condition, doWhileLoop),
+                updateInductionVar,
+                IrConstImpl.boolean(loopConditionStartOffset, loopConditionEndOffset, context.irBuiltIns.booleanType, true)
+            )
+        )
+    }
+
    private fun buildJavaLikeDoWhileCounterLoop(
        oldLoop: IrLoop,
        newLoopCondition: IrExpression,
        newBody: IrExpression?
-    ): LoopReplacement? {
+    ): LoopReplacement {
        // Transform loop:
        //      while (<newLoopCondition>) {
        //          {
@@ -402,31 +457,19 @@ class ProgressionLoopHeader(
        //          val forLoopVariable = inductionVariable
        //          <originalLoopBody>
        //      } while ( { inductionVariable += step; true } )
-        val bodyBlock = newBody as? IrContainerExpression ?: return null
-        val forLoopNextBlock = bodyBlock.statements[0] as? IrContainerExpression ?: return null
-        if (forLoopNextBlock.origin != IrStatementOrigin.FOR_LOOP_NEXT) return null
-        val loopStep = forLoopNextBlock.statements.last() as? IrSetValue ?: return null
+        val bodyBlock = newBody as? IrContainerExpression
+            ?: throw AssertionError("newBody: ${newBody?.dump()}")
+        val forLoopNextBlock = bodyBlock.statements[0] as? IrContainerExpression
+            ?: throw AssertionError("bodyBlock[0]: ${bodyBlock.statements[0].dump()}")
+        if (forLoopNextBlock.origin != IrStatementOrigin.FOR_LOOP_NEXT)
+            throw AssertionError("FOR_LOOP_NEXT expected: ${forLoopNextBlock.dump()}")
+        val loopStep = forLoopNextBlock.statements.last() as? IrSetValue
+            ?: throw AssertionError("forLoopNextBlock.last: ${forLoopNextBlock.statements.last().dump()}")

-        val doWhileLoop = IrDoWhileLoopImpl(oldLoop.startOffset, oldLoop.endOffset, oldLoop.type, oldLoop.origin)
+        val doWhileLoop = IrDoWhileLoopImpl(oldLoop.startOffset, oldLoop.endOffset, oldLoop.type, context.doWhileCounterLoopOrigin)
        doWhileLoop.label = oldLoop.label

-        val conditionStartOffset = newLoopCondition.startOffset
-        val conditionEndOffset = newLoopCondition.endOffset
-        val negatedCondition =
-            IrCallImpl.fromSymbolOwner(conditionStartOffset, conditionEndOffset, booleanNot.symbol).apply {
-                dispatchReceiver = newLoopCondition
-            }
-
-        val negatedConditionCheck =
-            IrWhenImpl(
-                conditionStartOffset, conditionEndOffset, context.irBuiltIns.unitType, null,
-                listOf(
-                    IrBranchImpl(
-                        negatedCondition,
-                        IrBreakImpl(conditionStartOffset, conditionEndOffset, context.irBuiltIns.nothingType, doWhileLoop)
-                    )
-                )
-            )
+        val negatedConditionCheck = createNegatedConditionCheck(newLoopCondition, doWhileLoop)

        bodyBlock.statements[0] = negatedConditionCheck
        val loopVarAssignments =
@@ -455,23 +498,25 @@ class ProgressionLoopHeader(
        return LoopReplacement(doWhileLoop, doWhileLoop)
    }

-    private fun buildJavaLikeWhileCounterLoop(
-        oldLoop: IrLoop,
-        newLoopCondition: IrExpression,
-        newBody: IrExpression?
-    ): LoopReplacement {
-        //   while (inductionVar < last) {
-        //     val loopVar = inductionVar
-        //     inductionVar += step
-        //     // Loop body
-        //   }
-        val newLoop = IrWhileLoopImpl(oldLoop.startOffset, oldLoop.endOffset, oldLoop.type, oldLoop.origin).apply {
-            label = oldLoop.label
-            condition = newLoopCondition
-            body = newBody
-        }
-        return LoopReplacement(newLoop, newLoop)
+    private fun createNegatedConditionCheck(newLoopCondition: IrExpression, doWhileLoop: IrDoWhileLoop): IrWhenImpl {
+        val conditionStartOffset = newLoopCondition.startOffset
+        val conditionEndOffset = newLoopCondition.endOffset
+        val negatedCondition =
+            IrCallImpl.fromSymbolOwner(conditionStartOffset, conditionEndOffset, booleanNot.symbol).apply {
+                dispatchReceiver = newLoopCondition
+            }
+
+        return IrWhenImpl(
+            conditionStartOffset, conditionEndOffset, context.irBuiltIns.unitType, null,
+            listOf(
+                IrBranchImpl(
+                    negatedCondition,
+                    IrBreakImpl(conditionStartOffset, conditionEndOffset, context.irBuiltIns.nothingType, doWhileLoop)
+                )
+            )
+        )
    }
+
 }

 private class InitializerCallReplacer(val replacementCall: IrCall) : IrElementTransformerVoid() {
@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
+import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
 import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.types.IrTypeSystemContext
@@ -217,6 +218,12 @@ class JvmBackendContext(
    override val preferJavaLikeCounterLoop: Boolean
        get() = true

+    override val reuseLoopVariableAsInductionVariable: Boolean
+        get() = true
+
+    override val doWhileCounterLoopOrigin: IrStatementOrigin
+        get() = JvmLoweredStatementOrigin.DO_WHILE_COUNTER_LOOP
+
    inner class JvmIr(
        irModuleFragment: IrModuleFragment,
        symbolTable: SymbolTable
@@ -9,4 +9,5 @@ import org.jetbrains.kotlin.ir.expressions.IrStatementOriginImpl

 interface JvmLoweredStatementOrigin {
    object DEFAULT_STUB_CALL_TO_IMPLEMENTATION : IrStatementOriginImpl("DEFAULT_STUB_CALL_TO_IMPLEMENTATION")
+    object DO_WHILE_COUNTER_LOOP: IrStatementOriginImpl("DO_WHILE_COUNTER_LOOP")
 }
@@ -1,5 +1,4 @@
 // IGNORE_BACKEND_FIR: JVM_IR
-// IGNORE_BACKEND: JVM_IR
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
 // WITH_COROUTINES
@@ -1,113 +0,0 @@
-// IGNORE_BACKEND_FIR: JVM_IR
-// IGNORE_BACKEND: JVM
-// TARGET_BACKEND: JVM
-// WITH_RUNTIME
-// WITH_COROUTINES
-
-@file:Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER", "CANNOT_OVERRIDE_INVISIBLE_MEMBER")
-
-import helpers.*
-import kotlin.coroutines.*
-import kotlin.coroutines.intrinsics.*
-import kotlin.coroutines.jvm.internal.*
-
-suspend fun getSpilledToVariable() = suspendCoroutineUninterceptedOrReturn<Array<String>> {
-    (it as BaseContinuationImpl).getSpilledVariableFieldMapping()
-}
-
-fun Array<String>.toMap(): Map<String, String> {
-    val res = hashMapOf<String, String>()
-    for (i in 0..(size - 1) step 2) {
-        res[get(i)] = get(i + 1)
-    }
-    return res
-}
-
-var continuation: Continuation<Unit>? = null
-
-suspend fun suspendHere() = suspendCoroutineUninterceptedOrReturn<Unit> {
-    continuation = it
-    COROUTINE_SUSPENDED
-}
-
-suspend fun dummy() {}
-
-suspend fun named(): String {
-    dummy()
-    val s1 = ""
-    val s2 = ""
-    val s3 = ""
-    val s4 = ""
-    val s5 = ""
-    val s6 = ""
-    val s7 = ""
-    val s8 = ""
-    val s9 = ""
-    val map = getSpilledToVariable().toMap()
-    println(s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9)
-    return map["L$0"] + map["L$1"] + map["L$2"] + map["L$3"] + map["L$4"] + map["L$5"] + map["L$6"] + map["L$7"] + map["L$8"]
-}
-
-suspend fun suspended() {
-    dummy()
-    val ss = ""
-    suspendHere()
-    println(ss)
-}
-
-suspend fun multipleLocalsInOneSlot() {
-    for (first in 0 until 1) {
-        suspendHere()
-        println(first)
-    }
-    for (second in 0 until 1) {
-        suspendHere()
-        println(second)
-    }
-}
-
-fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(EmptyContinuation)
-}
-
-fun box(): String {
-    var res: String = ""
-    builder {
-        res = named()
-    }
-    if (res != "s1s2s3s4s5s6s7s8s9") {
-        return "" + res
-    }
-    builder {
-        dummy()
-        val a = ""
-        res = getSpilledToVariable().toMap()["L$0"] ?: "lambda fail"
-        println(a)
-    }
-    if (res != "a") {
-        return "" + res
-    }
-
-    builder {
-        suspended()
-    }
-    res = (continuation!! as BaseContinuationImpl).getSpilledVariableFieldMapping()!!.toMap()["L$0"] ?: "suspended fail"
-    if (res != "ss") {
-        return "" + res
-    }
-
-    builder {
-        multipleLocalsInOneSlot()
-    }
-    res = (continuation!! as BaseContinuationImpl).getSpilledVariableFieldMapping()!!.toMap()["I$1"] ?: "multipleLocalsInOneSlot fail 1"
-    if (res != "first") {
-        return "" + res
-    }
-    continuation!!.resumeWith(Result.success(Unit))
-    res = (continuation!! as BaseContinuationImpl).getSpilledVariableFieldMapping()!!.toMap()["I$1"] ?: "multipleLocalsInOneSlot fail 2"
-    if (res != "second") {
-        return "" + res
-    }
-
-    return "OK"
-}
@@ -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 {
@@ -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 {
@@ -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 {
@@ -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 {
@@ -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 {
@@ -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") {
@@ -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) {
@@ -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 {
@@ -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"
@@ -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()

@@ -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 {
@@ -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 {
@@ -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) {}
@@ -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 {
@@ -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 {
@@ -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 {
@@ -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")
@@ -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) {
@@ -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) {
@@ -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) {
@@ -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) {
@@ -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) {
@@ -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 {
@@ -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) {
@@ -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) {
@@ -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 {
@@ -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()

@@ -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 {
@@ -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 {
@@ -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 {
@@ -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) {}
@@ -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 {
@@ -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)

@@ -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()) {
    }
@@ -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()) {
    }
@@ -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()) {
    }
@@ -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()) {
    }
@@ -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()) {
    }
@@ -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()) {
    }
@@ -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()) {
    }
@@ -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()) {
    }
@@ -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()) {
    }
@@ -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()) {
    }
@@ -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()) {
    }
@@ -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()) {
    }
@@ -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
@@ -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 {
@@ -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 {
@@ -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
@@ -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 {
@@ -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 {
@@ -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 {
@@ -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
@@ -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)) {
@@ -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
@@ -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 {
@@ -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 {
@@ -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 {
@@ -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 {
@@ -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")
@@ -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
@@ -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 {
@@ -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 {
@@ -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 {
@@ -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
@@ -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 {
@@ -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 {
@@ -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 {
@@ -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()

@@ -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 {
@@ -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 {
@@ -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 {
@@ -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()

@@ -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) {}
@@ -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") {
@@ -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) {
@@ -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 {
@@ -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 {
@@ -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) {
@@ -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 {
@@ -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 {
@@ -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) {
@@ -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 {
@@ -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 {
@@ -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) {
@@ -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) {} }
@@ -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) =
@@ -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)
@@ -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) {
    }
@@ -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) {
    }
@@ -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
--- a/Show More
+++ b/Show More