azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adapt to IR change to allow setting of parameters for default stubs.

Browse Source 
(cherry picked from commit 68034d3c816387b4000c1b298dbea5b800643fe7)
This commit is contained in:
Mads Ager
2020-09-10 12:35:49 +02:00
committed by Vasily Levchenko
parent ad39f45304
commit 11a3085659
11 changed files with 76 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/common/AbstractValueUsageTransformer.kt
+5 -2
View File
@@ -61,6 +61,9 @@ internal abstract class AbstractValueUsageTransformer(
private fun IrExpression.useForVariable(variable: IrVariable): IrExpression =
this.useAsValue(variable)
private fun IrExpression.useForValue(value: IrValueDeclaration) =
this.useAsValue(value)
private fun IrExpression.useForField(field: IrField): IrExpression =
this.useAs(field.type)
@@ -144,10 +147,10 @@ internal abstract class AbstractValueUsageTransformer(
return expression
}
override fun visitSetVariable(expression: IrSetVariable): IrExpression {
override fun visitSetValue(expression: IrSetValue): IrExpression {
expression.transformChildrenVoid(this)
expression.value = expression.value.useForVariable(expression.symbol.owner)
expression.value = expression.value.useForValue(expression.symbol.owner)
return expression
}
backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/KonanSharedVariablesManager.kt
+2 -2
View File
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.ir.declarations.IrVariable
import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
import org.jetbrains.kotlin.ir.descriptors.WrappedVariableDescriptor
import org.jetbrains.kotlin.ir.expressions.IrGetValue
import org.jetbrains.kotlin.ir.expressions.IrSetVariable
import org.jetbrains.kotlin.ir.expressions.IrSetValue
import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrCompositeImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl
@@ -87,7 +87,7 @@ internal class KonanSharedVariablesManager(val context: KonanBackendContext) : S
)
}
override fun setSharedValue(sharedVariableSymbol: IrVariableSymbol, originalSet: IrSetVariable) =
override fun setSharedValue(sharedVariableSymbol: IrVariableSymbol, originalSet: IrSetValue) =
IrCallImpl(originalSet.startOffset, originalSet.endOffset, context.irBuiltIns.unitType,
elementProperty.setter!!.symbol).apply {
dispatchReceiver = IrGetValueImpl(
backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt
+10 -10
View File
@@ -130,9 +130,9 @@ internal interface CodeContext {
fun genDeclareVariable(variable: IrVariable, value: LLVMValueRef?, variableLocation: VariableDebugLocation?): Int
/**
* @return index of variable declared before, or -1 if no such variable has been declared yet.
* @return index of value declared before, or -1 if no such variable has been declared yet.
*/
fun getDeclaredVariable(variable: IrVariable): Int
fun getDeclaredValue(value: IrValueDeclaration): Int
/**
* Generates the code to obtain a value available in this context.
@@ -244,7 +244,7 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
override fun genDeclareVariable(variable: IrVariable, value: LLVMValueRef?, variableLocation: VariableDebugLocation?) = unsupported(variable)
override fun getDeclaredVariable(variable: IrVariable) = -1
override fun getDeclaredValue(value: IrValueDeclaration) = -1
override fun genGetValue(value: IrValueDeclaration) = unsupported(value)
@@ -576,9 +576,9 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
return functionGenerationContext.vars.createVariable(variable, value, variableLocation)
}
override fun getDeclaredVariable(variable: IrVariable): Int {
val index = functionGenerationContext.vars.indexOf(variable)
return if (index < 0) super.getDeclaredVariable(variable) else return index
override fun getDeclaredValue(value: IrValueDeclaration): Int {
val index = functionGenerationContext.vars.indexOf(value)
return if (index < 0) super.getDeclaredValue(value) else index
}
override fun genGetValue(value: IrValueDeclaration): LLVMValueRef {
@@ -862,7 +862,7 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
is IrInstanceInitializerCall ->
return evaluateInstanceInitializerCall(value)
is IrGetValue -> return evaluateGetValue (value)
is IrSetVariable -> return evaluateSetVariable (value)
is IrSetValue -> return evaluateSetValue (value)
is IrGetField -> return evaluateGetField (value)
is IrSetField -> return evaluateSetField (value)
is IrConst<*> -> return evaluateConst (value)
@@ -1267,10 +1267,10 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
//-------------------------------------------------------------------------//
private fun evaluateSetVariable(value: IrSetVariable): LLVMValueRef {
context.log{"evaluateSetVariable : ${ir2string(value)}"}
private fun evaluateSetValue(value: IrSetValue): LLVMValueRef {
context.log{"evaluateSetValue : ${ir2string(value)}"}
val result = evaluateExpression(value.value)
val variable = currentCodeContext.getDeclaredVariable(value.symbol.owner)
val variable = currentCodeContext.getDeclaredValue(value.symbol.owner)
functionGenerationContext.vars.store(result, variable)
assert(value.type.isUnit())
return functionGenerationContext.theUnitInstanceRef.llvm
backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/VariableManager.kt
+1 -1
View File
@@ -33,7 +33,7 @@ internal class VariableManager(val functionGenerationContext: FunctionGeneration
inner class ParameterRecord(val address: LLVMValueRef, val refSlot: Boolean) : Record {
override fun load() : LLVMValueRef = functionGenerationContext.loadSlot(address, false)
override fun store(value: LLVMValueRef) = throw Error("writing to parameter")
override fun store(value: LLVMValueRef) = functionGenerationContext.store(value, address)
override fun address() : LLVMValueRef = this.address
override fun toString() = (if (refSlot) "refslot" else "slot") + " for ${address}"
}
backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/Autoboxing.kt
+6 -1
View File
@@ -121,7 +121,6 @@ private class AutoboxingTransformer(val context: Context) : AbstractValueUsageTr
else -> this.type
}
return this.adaptIfNecessary(actualType, type)
}
@@ -469,6 +468,12 @@ private class InlineClassTransformer(private val context: Context) : IrBuildingT
return expression
}
override fun visitSetValue(expression: IrSetValue): IrExpression {
expression.transformChildrenVoid()
parameterMapping[expression.symbol]?.let { return irSet(it.symbol, expression.value) }
return expression
}
override fun visitReturn(expression: IrReturn): IrExpression {
expression.transformChildrenVoid()
if (expression.returnTargetSymbol == irConstructor.symbol) {
backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/BridgesBuilding.kt
+2 -1
View File
@@ -98,7 +98,8 @@ internal class WorkersBridgesBuilding(val context: Context) : DeclarationContain
type = context.irBuiltIns.anyNType,
varargElementType = null,
isCrossinline = arg.isCrossinline,
isNoinline = arg.isNoinline
isNoinline = arg.isNoinline,
isAssignable = arg.isAssignable
).apply { it.bind(this) }
}
}
backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/EnumConstructorsLowering.kt
+24
View File
@@ -351,6 +351,14 @@ internal class EnumConstructorsLowering(val context: Context) : ClassLoweringPas
loweredParameter.symbol, expression.origin)
}
}
override fun visitSetValue(expression: IrSetValue): IrExpression {
expression.transformChildrenVoid()
return loweredEnumConstructorParameters[expression.symbol.owner]?.let {
IrSetValueImpl(expression.startOffset, expression.endOffset, it.type,
it.symbol, expression.value, expression.origin)
} ?: expression
}
}
}
}
@@ -375,4 +383,20 @@ private class ParameterMapper(superConstructor: IrConstructor,
}
return expression
}
override fun visitSetValue(expression: IrSetValue): IrExpression {
expression.transformChildrenVoid()
val superParameter = expression.symbol.owner as? IrValueParameter ?: return expression
if (valueParameters.contains(superParameter)) {
val index = if (useLoweredIndex) superParameter.loweredIndex else superParameter.index
val parameter = constructor.valueParameters[index]
return IrSetValueImpl(
expression.startOffset, expression.endOffset,
parameter.type,
parameter.symbol,
expression.value,
expression.origin)
}
return expression
}
}
backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/NativeSuspendFunctionLowering.kt
+11 -4
View File
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.ir.descriptors.WrappedSimpleFunctionDescriptor
import org.jetbrains.kotlin.ir.descriptors.WrappedVariableDescriptor
import org.jetbrains.kotlin.ir.expressions.*
import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrSetVariableImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrSetValueImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrSuspendableExpressionImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrSuspensionPointImpl
import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
@@ -123,6 +123,13 @@ internal class NativeSuspendFunctionsLowering(ctx: Context): AbstractSuspendFunc
return irGetField(irGet(thisReceiver), capturedValue)
}
override fun visitSetValue(expression: IrSetValue): IrExpression {
expression.transformChildrenVoid(this)
val capturedValue = argumentToPropertiesMap[expression.symbol.owner]
?: return expression
return irSetField(irGet(thisReceiver), capturedValue, expression.value)
}
// Save/restore state at suspension points.
override fun visitExpression(expression: IrExpression): IrExpression {
expression.transformChildrenVoid(this)
@@ -202,13 +209,13 @@ internal class NativeSuspendFunctionsLowering(ctx: Context): AbstractSuspendFunc
origin = expression.origin)
}
override fun visitSetVariable(expression: IrSetVariable): IrExpression {
override fun visitSetValue(expression: IrSetValue): IrExpression {
expression.transformChildrenVoid(this)
val newVariable = variablesMap[expression.symbol.owner]
?: return expression
return IrSetVariableImpl(
return IrSetValueImpl(
startOffset = expression.startOffset,
endOffset = expression.endOffset,
type = context.irBuiltIns.unitType,
@@ -384,7 +391,7 @@ internal class NativeSuspendFunctionsLowering(ctx: Context): AbstractSuspendFunc
result = irBlock(startOffset, endOffset) {
if (!calledSaveState)
+irCall(saveState)
+irSetVar(suspendResult.symbol, suspendCall)
+irSet(suspendResult.symbol, suspendCall)
+irReturnIfSuspended(suspendResult)
+irGet(suspendResult)
},
backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/VarargLowering.kt
+1 -1
View File
@@ -165,7 +165,7 @@ internal class VarargInjectionLowering constructor(val context: KonanBackendCont
}
private fun IrBuilderWithScope.incrementVariable(variable: IrVariable, value: IrExpression): IrExpression {
return irSetVar(variable.symbol, intPlus().apply {
return irSet(variable.symbol, intPlus().apply {
dispatchReceiver = irGet(variable)
putValueArgument(0, value)
})
backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DFGBuilder.kt
+13 -13
View File
@@ -56,16 +56,16 @@ private fun IrTypeOperator.callsInstanceOf() =
private class VariableValues {
data class Variable(val loop: IrLoop?, val values: MutableSet<IrExpression>)
val elementData = HashMap<IrVariable, Variable>()
val elementData = HashMap<IrValueDeclaration, Variable>()
fun addEmpty(variable: IrVariable, loop: IrLoop?) {
fun addEmpty(variable: IrValueDeclaration, loop: IrLoop?) {
elementData[variable] = Variable(loop, mutableSetOf())
}
fun add(variable: IrVariable, element: IrExpression) =
fun add(variable: IrValueDeclaration, element: IrExpression) =
elementData[variable]?.values?.add(element)
private fun add(variable: IrVariable, elements: Set<IrExpression>) =
private fun add(variable: IrValueDeclaration, elements: Set<IrExpression>) =
elementData[variable]?.values?.addAll(elements)
fun computeClosure() {
@@ -75,14 +75,14 @@ private class VariableValues {
}
// Computes closure of all possible values for given variable.
private fun computeValueClosure(value: IrVariable): Set<IrExpression> {
private fun computeValueClosure(value: IrValueDeclaration): Set<IrExpression> {
val result = mutableSetOf<IrExpression>()
val seen = mutableSetOf<IrVariable>()
val seen = mutableSetOf<IrValueDeclaration>()
dfs(value, seen, result)
return result
}
private fun dfs(value: IrVariable, seen: MutableSet<IrVariable>, result: MutableSet<IrExpression>) {
private fun dfs(value: IrValueDeclaration, seen: MutableSet<IrValueDeclaration>, result: MutableSet<IrExpression>) {
seen += value
val elements = elementData[value]?.values ?: return
for (element in elements) {
@@ -313,7 +313,7 @@ internal class ModuleDFGBuilder(val context: Context, val irModule: IrModuleFrag
element.acceptChildrenVoid(this)
}
private fun assignVariable(variable: IrVariable, value: IrExpression) {
private fun assignValue(variable: IrValueDeclaration, value: IrExpression) {
expressionValuesExtractor.forEachValue(value) {
variableValues.add(variable, it)
}
@@ -410,15 +410,15 @@ internal class ModuleDFGBuilder(val context: Context, val irModule: IrModuleFrag
super.visitCatch(aCatch)
}
override fun visitSetVariable(expression: IrSetVariable) {
super.visitSetVariable(expression)
assignVariable(expression.symbol.owner, expression.value)
override fun visitSetValue(expression: IrSetValue) {
super.visitSetValue(expression)
assignValue(expression.symbol.owner, expression.value)
}
override fun visitVariable(declaration: IrVariable) {
variableValues.addEmpty(declaration, currentLoop)
super.visitVariable(declaration)
declaration.initializer?.let { assignVariable(declaration, it) }
declaration.initializer?.let { assignValue(declaration, it) }
}
}
@@ -473,7 +473,7 @@ internal class ModuleDFGBuilder(val context: Context, val irModule: IrModuleFrag
?: error("Function ${declaration.descriptor} has no continuation parameter")
private val nodes = mutableMapOf<IrExpression, Scoped<DataFlowIR.Node>>()
private val variables = mutableMapOf<IrVariable, Scoped<DataFlowIR.Node.Variable>>()
private val variables = mutableMapOf<IrValueDeclaration, Scoped<DataFlowIR.Node.Variable>>()
private val expressionsScopes = mutableMapOf<IrExpression, DataFlowIR.Node.Scope>()
fun build(): DataFlowIR.Function {
backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/ir/util/IrUtils2.kt
+1 -1
View File
@@ -259,7 +259,7 @@ fun IrBuilderWithScope.irCallOp(
}
fun IrBuilderWithScope.irSetVar(variable: IrVariable, value: IrExpression) =
irSetVar(variable.symbol, value)
irSet(variable.symbol, value)
fun IrBuilderWithScope.irCatch(type: IrType) =
IrCatchImpl(