From e3857223ebab9780e9904d7af1a8ead8f2636061 Mon Sep 17 00:00:00 2001 From: Igor Chevdar Date: Tue, 6 Mar 2018 17:21:23 +0300 Subject: [PATCH] DFG: Added Type.correspondingValueType --- .../konan/optimizations/DFGSerializer.kt | 19 +++++++----- .../backend/konan/optimizations/DataFlowIR.kt | 29 +++++++++---------- 2 files changed, 26 insertions(+), 22 deletions(-) diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DFGSerializer.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DFGSerializer.kt index e9583734019..f4d29e7e726 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DFGSerializer.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DFGSerializer.kt @@ -17,6 +17,7 @@ package org.jetbrains.kotlin.backend.konan.optimizations import org.jetbrains.kotlin.backend.konan.Context +import org.jetbrains.kotlin.backend.konan.ValueType import org.jetbrains.kotlin.config.CommonConfigurationKeys import sun.misc.Unsafe import kotlin.reflect.KClass @@ -223,15 +224,16 @@ internal object DFGSerializer { } } - class DeclaredType(val isFinal: Boolean, val isAbstract: Boolean, val index: Int, val superTypes: IntArray, - val vtable: IntArray, val itable: Array) { + class DeclaredType(val isFinal: Boolean, val isAbstract: Boolean, val correspondingValueType: ValueType?, + val index: Int, val superTypes: IntArray, val vtable: IntArray, val itable: Array) { - constructor(data: ArraySlice) : this(data.readBoolean(), data.readBoolean(), data.readInt(), data.readIntArray(), - data.readIntArray(), data.readArray { ItableSlot(this) }) + constructor(data: ArraySlice) : this(data.readBoolean(), data.readBoolean(), data.readNullableInt()?.let { ValueType.values()[it] }, + data.readInt(), data.readIntArray(), data.readIntArray(), data.readArray { ItableSlot(this) }) fun write(result: ArraySlice) { result.writeBoolean(isFinal) result.writeBoolean(isAbstract) + result.writeNullableInt(correspondingValueType?.ordinal) result.writeInt(index) result.writeIntArray(superTypes) result.writeIntArray(vtable) @@ -759,10 +761,12 @@ internal object DFGSerializer { val types = typeMap.entries .sortedBy { it.value } .map { + fun buildTypeIntestines(type: DataFlowIR.Type.Declared) = DeclaredType( type.isFinal, type.isAbstract, + type.correspondingValueType, type.symbolTableIndex, type.superTypes.map { typeMap[it]!! }.toIntArray(), type.vtable.map { functionSymbolMap[it]!! }.toIntArray(), @@ -927,8 +931,8 @@ internal object DFGSerializer { val symbolTableIndex = public.intestines.index if (symbolTableIndex >= 0) ++module.numberOfClasses - DataFlowIR.Type.Public(public.hash, public.intestines.isFinal, - public.intestines.isAbstract, module, symbolTableIndex, public.name).also { + DataFlowIR.Type.Public(public.hash, public.intestines.isFinal, public.intestines.isAbstract, + public.intestines.correspondingValueType, module, symbolTableIndex, public.name).also { publicTypesMap.put(it.hash, it) allTypes += it } @@ -939,7 +943,8 @@ internal object DFGSerializer { if (symbolTableIndex >= 0) ++module.numberOfClasses DataFlowIR.Type.Private(privateTypeIndex++, private.intestines.isFinal, - private.intestines.isAbstract, module, symbolTableIndex, private.name).also { + private.intestines.isAbstract, private.intestines.correspondingValueType, + module, symbolTableIndex, private.name).also { allTypes += it } } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt index 1a882ac8fb1..33af70dcfcf 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt @@ -16,13 +16,10 @@ package org.jetbrains.kotlin.backend.konan.optimizations -import org.jetbrains.kotlin.backend.common.descriptors.allParameters -import org.jetbrains.kotlin.backend.konan.Context +import org.jetbrains.kotlin.backend.konan.* import org.jetbrains.kotlin.backend.konan.descriptors.isAbstract import org.jetbrains.kotlin.backend.konan.descriptors.isInterface import org.jetbrains.kotlin.backend.konan.irasdescriptors.* -import org.jetbrains.kotlin.backend.konan.isObjCClass -import org.jetbrains.kotlin.backend.konan.isValueType import org.jetbrains.kotlin.backend.konan.llvm.functionName import org.jetbrains.kotlin.backend.konan.llvm.isExported import org.jetbrains.kotlin.backend.konan.llvm.localHash @@ -43,8 +40,6 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.constants.ConstantValue import org.jetbrains.kotlin.resolve.constants.IntValue -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe -import org.jetbrains.kotlin.resolve.descriptorUtil.module import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.typeUtil.immediateSupertypes @@ -52,7 +47,7 @@ internal object DataFlowIR { abstract class Type { // Special marker type forbidding devirtualization on its instances. - object Virtual : Declared(false, true, null, -1) + object Virtual : Declared(false, true, null, null, -1) class External(val hash: Long, val name: String? = null) : Type() { override fun equals(other: Any?): Boolean { @@ -71,14 +66,16 @@ internal object DataFlowIR { } } - abstract class Declared(val isFinal: Boolean, val isAbstract: Boolean, val module: Module?, val symbolTableIndex: Int) : Type() { + abstract class Declared(val isFinal: Boolean, val isAbstract: Boolean, val correspondingValueType: ValueType?, + val module: Module?, val symbolTableIndex: Int) : Type() { val superTypes = mutableListOf() val vtable = mutableListOf() val itable = mutableMapOf() } - class Public(val hash: Long, isFinal: Boolean, isAbstract: Boolean, module: Module, symbolTableIndex: Int, val name: String? = null) - : Declared(isFinal, isAbstract, module, symbolTableIndex) { + class Public(val hash: Long, isFinal: Boolean, isAbstract: Boolean, correspondingValueType: ValueType?, + module: Module, symbolTableIndex: Int, val name: String? = null) + : Declared(isFinal, isAbstract, correspondingValueType, module, symbolTableIndex) { override fun equals(other: Any?): Boolean { if (this === other) return true if (other !is Public) return false @@ -95,8 +92,9 @@ internal object DataFlowIR { } } - class Private(val index: Int, isFinal: Boolean, isAbstract: Boolean, module: Module, symbolTableIndex: Int, val name: String? = null) - : Declared(isFinal, isAbstract, module, symbolTableIndex) { + class Private(val index: Int, isFinal: Boolean, isAbstract: Boolean, correspondingValueType: ValueType?, + module: Module, symbolTableIndex: Int, val name: String? = null) + : Declared(isFinal, isAbstract, correspondingValueType, module, symbolTableIndex) { override fun equals(other: Any?): Boolean { if (this === other) return true if (other !is Private) return false @@ -481,12 +479,13 @@ internal object DataFlowIR { val isFinal = descriptor.isFinal() val isAbstract = descriptor.isAbstract() - val placeToClassTable = !descriptor.defaultType.isValueType() + val correspondingValueType = descriptor.defaultType.correspondingValueType + val placeToClassTable = correspondingValueType == null val symbolTableIndex = if (placeToClassTable) module.numberOfClasses++ else -1 val type = if (descriptor.isExported()) - Type.Public(name.localHash.value, isFinal, isAbstract, module, symbolTableIndex, takeName { name }) + Type.Public(name.localHash.value, isFinal, isAbstract, correspondingValueType, module, symbolTableIndex, takeName { name }) else - Type.Private(privateTypeIndex++, isFinal, isAbstract, module, symbolTableIndex, takeName { name }) + Type.Private(privateTypeIndex++, isFinal, isAbstract, correspondingValueType, module, symbolTableIndex, takeName { name }) if (!isAbstract) { val vtableBuilder = context.getVtableBuilder(descriptor) type.vtable += vtableBuilder.vtableEntries.map { mapFunction(it.getImplementation(context)!!) }