From 66facac25bb61b009f893fa9a2a95ca16e0cf0b6 Mon Sep 17 00:00:00 2001 From: Ilya Gorbunov Date: Wed, 10 Aug 2022 15:47:24 +0200 Subject: [PATCH] Implement JVM intrinsic for rangeUntil builtin member operator #KT-52933 --- .../jvm/intrinsics/IrIntrinsicMethods.kt | 16 +--- .../kotlin/backend/jvm/intrinsics/Range.kt | 74 ------------------- .../kotlin/backend/jvm/intrinsics/RangeTo.kt | 68 +++++++++++++---- .../backend/jvm/intrinsics/RangeUntil.kt | 37 ++++++---- 4 files changed, 80 insertions(+), 115 deletions(-) delete mode 100644 compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Range.kt diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicMethods.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicMethods.kt index 2a2bbb633da..15182c00841 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicMethods.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicMethods.kt @@ -1,17 +1,6 @@ /* - * Copyright 2010-2016 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ package org.jetbrains.kotlin.backend.jvm.intrinsics @@ -104,6 +93,7 @@ class IrIntrinsicMethods(val irBuiltIns: IrBuiltIns, val symbols: JvmSymbols) { unaryFunForPrimitives("hashCode", HashCode) + binaryFunForPrimitives("equals", EXPLICIT_EQUALS, irBuiltIns.anyClass) + binaryFunForPrimitivesAcrossPrimitives("rangeTo", RangeTo) + + binaryFunForPrimitivesAcrossPrimitives("rangeUntil", RangeUntil) + binaryOp("plus", IADD) + binaryOp("minus", ISUB) + binaryOp("times", IMUL) + diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Range.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Range.kt deleted file mode 100644 index dcad462cd31..00000000000 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Range.kt +++ /dev/null @@ -1,74 +0,0 @@ -/* - * Copyright 2010-2016 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.backend.jvm.intrinsics - -import org.jetbrains.kotlin.backend.jvm.codegen.BlockInfo -import org.jetbrains.kotlin.backend.jvm.codegen.ExpressionCodegen -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext -import org.jetbrains.kotlin.codegen.StackValue -import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature -import org.jetbrains.kotlin.types.AbstractTypeMapper -import org.jetbrains.org.objectweb.asm.Type -import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter -import java.lang.IllegalStateException - -abstract class Range(private val kind: RangeKind) : IntrinsicMethod() { - private fun mapRangeTypeToPrimitiveType(rangeType: Type, kind: RangeKind): Type { - val fqName = rangeType.internalName - return when (fqName.substringAfter("kotlin/ranges/").substringBefore("Range")) { - "Double" -> Type.DOUBLE_TYPE - "Float" -> Type.FLOAT_TYPE - "Long" -> Type.LONG_TYPE - "Int" -> Type.INT_TYPE - "Short" -> Type.SHORT_TYPE - "Char" -> Type.CHAR_TYPE - "Byte" -> Type.BYTE_TYPE - else -> throw IllegalStateException("${kind.desc} intrinsic can only work for primitive types: $fqName") - } - } - - override fun toCallable( - expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext - ): IrIntrinsicFunction { - val argType = mapRangeTypeToPrimitiveType(signature.returnType, kind) - return object : IrIntrinsicFunction(expression, signature, context, listOf(argType) + signature.valueParameters.map { argType }) { - override fun genInvokeInstruction(v: InstructionAdapter) { - v.invokespecial( - signature.returnType.internalName, - "", - Type.getMethodDescriptor(Type.VOID_TYPE, argType, argType), - false - ) - } - - override fun invoke( - v: InstructionAdapter, - codegen: ExpressionCodegen, - data: BlockInfo, - expression: IrFunctionAccessExpression - ): StackValue { - codegen.markLineNumber(expression) - v.anew(returnType) - v.dup() - return super.invoke(v, codegen, data, expression) - } - } - } - - enum class RangeKind(val desc: String) { TO("RangeTo"), UNTIL("RangeUntil") } -} diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeTo.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeTo.kt index 607784184b9..69fb6401712 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeTo.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeTo.kt @@ -1,19 +1,59 @@ /* - * Copyright 2010-2016 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ package org.jetbrains.kotlin.backend.jvm.intrinsics -object RangeTo : Range(RangeKind.TO) +import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.BlockInfo +import org.jetbrains.kotlin.backend.jvm.codegen.ExpressionCodegen +import org.jetbrains.kotlin.codegen.StackValue +import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression +import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature +import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter +import org.jetbrains.org.objectweb.asm.Type + +object RangeTo : IntrinsicMethod() { + override fun toCallable( + expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext + ): IrIntrinsicFunction { + val argType = mapRangeTypeToPrimitiveType(signature.returnType) + return object : IrIntrinsicFunction(expression, signature, context, listOf(argType) + signature.valueParameters.map { argType }) { + override fun genInvokeInstruction(v: InstructionAdapter) { + v.invokespecial( + signature.returnType.internalName, + "", + Type.getMethodDescriptor(Type.VOID_TYPE, argType, argType), + false + ) + } + + override fun invoke( + v: InstructionAdapter, + codegen: ExpressionCodegen, + data: BlockInfo, + expression: IrFunctionAccessExpression + ): StackValue { + codegen.markLineNumber(expression) + v.anew(returnType) + v.dup() + return super.invoke(v, codegen, data, expression) + } + } + } + + private fun mapRangeTypeToPrimitiveType(rangeType: Type): Type { + val fqName = rangeType.internalName + return when (fqName.substringAfter("kotlin/ranges/").substringBefore("Range")) { + "Double" -> Type.DOUBLE_TYPE + "Float" -> Type.FLOAT_TYPE + "Long" -> Type.LONG_TYPE + "Int" -> Type.INT_TYPE + "Short" -> Type.SHORT_TYPE + "Char" -> Type.CHAR_TYPE + "Byte" -> Type.BYTE_TYPE + else -> throw IllegalStateException("RangeTo intrinsic can only work for primitive types: $fqName") + } + } +} diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeUntil.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeUntil.kt index 4ccc2c4e8b0..aa2bc1039d3 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeUntil.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeUntil.kt @@ -1,19 +1,28 @@ /* - * Copyright 2010-2016 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ package org.jetbrains.kotlin.backend.jvm.intrinsics -object RangeUntil : Range(RangeKind.UNTIL) +import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression +import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature +import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter +import org.jetbrains.org.objectweb.asm.Type + +object RangeUntil : IntrinsicMethod() { + override fun toCallable( + expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext + ): IrIntrinsicFunction { + return object : IrIntrinsicFunction(expression, signature, context) { + override fun genInvokeInstruction(v: InstructionAdapter) { + v.invokestatic( + "kotlin/ranges/RangesKt", "until", + Type.getMethodDescriptor(signature.returnType, *argsTypes.toTypedArray()), + false + ) + } + } + } +}