From 4dcee48e1f5afc2a2070040a8801ba4f449d83a4 Mon Sep 17 00:00:00 2001 From: Igor Chevdar Date: Wed, 3 May 2017 17:24:01 +0500 Subject: [PATCH] Removed CodeContext from scope of a variable --- .../kotlin/backend/konan/llvm/IrToBitcode.kt | 10 ++--- .../backend/konan/llvm/VariableManager.kt | 40 +++++++------------ 2 files changed, 20 insertions(+), 30 deletions(-) diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt index ca3e07d9cf6..99cacf6d258 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt @@ -431,16 +431,16 @@ internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid private inner class VariableScope : InnerScopeImpl() { override fun genDeclareVariable(descriptor: VariableDescriptor, value: LLVMValueRef?): Int { - return codegen.vars.createVariable(descriptor to this, value) + return codegen.vars.createVariable(descriptor, value) } override fun getDeclaredVariable(descriptor: VariableDescriptor): Int { - val index = codegen.vars.indexOf(descriptor to this) + val index = codegen.vars.indexOf(descriptor) return if (index < 0) super.getDeclaredVariable(descriptor) else return index } override fun genGetValue(descriptor: ValueDescriptor): LLVMValueRef { - val index = codegen.vars.indexOf(descriptor to this) + val index = codegen.vars.indexOf(descriptor) if (index < 0) { return super.genGetValue(descriptor) } else { @@ -460,13 +460,13 @@ internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid init { parameters.map { (descriptor, value) -> - codegen.vars.createImmutable(descriptor to this, value) + codegen.vars.createImmutable(descriptor, value) } } override fun genGetValue(descriptor: ValueDescriptor): LLVMValueRef { - val index = codegen.vars.indexOf(descriptor to this) + val index = codegen.vars.indexOf(descriptor) if (index < 0) { return super.genGetValue(descriptor) } else { diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/VariableManager.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/VariableManager.kt index 4af209e87ca..8d6c69ea42a 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/VariableManager.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/VariableManager.kt @@ -19,7 +19,6 @@ package org.jetbrains.kotlin.backend.konan.llvm import llvm.* import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.types.* internal class VariableManager(val codegen: CodeGenerator) { @@ -43,13 +42,8 @@ internal class VariableManager(val codegen: CodeGenerator) { override fun toString() = "value of ${value} from ${name}" } - data class ScopedVariable private constructor(val descriptor: ValueDescriptor, val context: CodeContext) - { - constructor(scoped: Pair) : this(scoped.first, scoped.second) - } - val variables: ArrayList = arrayListOf() - val contextVariablesToIndex: HashMap = hashMapOf() + val contextVariablesToIndex: HashMap = hashMapOf() // Clears inner state of variable manager. fun clear() { @@ -57,31 +51,28 @@ internal class VariableManager(val codegen: CodeGenerator) { contextVariablesToIndex.clear() } - fun createVariable(scoped: Pair, value: LLVMValueRef? = null) : Int { + fun createVariable(descriptor: VariableDescriptor, value: LLVMValueRef? = null) : Int { // Note that we always create slot for object references for memory management. - val descriptor = scoped.first if (!descriptor.isVar && value != null) - return createImmutable(scoped, value) + return createImmutable(descriptor, value) else // Unfortunately, we have to create mutable slots here, // as even vals can be assigned on multiple paths. However, we use varness // knowledge, as anonymous slots are created only for true vars (for vals // their single assigner already have slot). - return createMutable(scoped, descriptor.isVar, value) + return createMutable(descriptor, descriptor.isVar, value) } - fun createMutable(scoped: Pair, + fun createMutable(descriptor: VariableDescriptor, isVar: Boolean, value: LLVMValueRef? = null) : Int { - val descriptor = scoped.first - val scopedVariable = ScopedVariable(scoped) - assert(!contextVariablesToIndex.contains(scopedVariable)) + assert(!contextVariablesToIndex.contains(descriptor)) val index = variables.size val type = codegen.getLLVMType(descriptor.type) - val slot = codegen.alloca(type, scopedVariable.descriptor.name.asString()) + val slot = codegen.alloca(type, descriptor.name.asString()) if (value != null) codegen.storeAnyLocal(value, slot) variables.add(SlotRecord(slot, codegen.isObjectType(type), isVar)) - contextVariablesToIndex[scopedVariable] = index + contextVariablesToIndex[descriptor] = index return index } @@ -101,18 +92,17 @@ internal class VariableManager(val codegen: CodeGenerator) { return index } - fun createImmutable(scoped: Pair, value: LLVMValueRef) : Int { - val scopedVariable = ScopedVariable(scoped) - if (contextVariablesToIndex.containsKey(scopedVariable)) - throw Error("${scopedVariable.descriptor} is already defined") + fun createImmutable(descriptor: ValueDescriptor, value: LLVMValueRef) : Int { + if (contextVariablesToIndex.containsKey(descriptor)) + throw Error("$descriptor is already defined") val index = variables.size - variables.add(ValueRecord(value, scopedVariable.descriptor.name)) - contextVariablesToIndex[scopedVariable] = index + variables.add(ValueRecord(value, descriptor.name)) + contextVariablesToIndex[descriptor] = index return index } - fun indexOf(scoped: Pair) : Int { - return contextVariablesToIndex.getOrElse(ScopedVariable(scoped)) { -1 } + fun indexOf(descriptor: ValueDescriptor) : Int { + return contextVariablesToIndex.getOrElse(descriptor) { -1 } } fun addressOf(index: Int): LLVMValueRef {