diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt index 22c7cb1d930..12f9d7dd1be 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt @@ -208,9 +208,8 @@ private inline fun generateFunctionBody( internal object VirtualTablesLookup { private fun FunctionGenerationContext.getInterfaceTableRecord(typeInfo: LLVMValueRef, interfaceId: Int): LLVMValueRef { - val interfaceTableRecordPtrType = pointerType(runtime.interfaceTableRecordType) - val interfaceTableSize = load(llvm.int32Type, structGep(typeInfo, 9 /* interfaceTableSize_ */)) - val interfaceTable = load(interfaceTableRecordPtrType, structGep(typeInfo, 10 /* interfaceTable_ */)) + val interfaceTableSize = load(structGep(typeInfo, 9 /* interfaceTableSize_ */)) + val interfaceTable = load(structGep(typeInfo, 10 /* interfaceTable_ */)) fun fastPath(): LLVMValueRef { // The fastest optimistic version. @@ -232,7 +231,7 @@ internal object VirtualTablesLookup { val takeResBB = basicBlock("take_res", startLocationInfo) condBr(icmpGe(interfaceTableSize, llvm.kImmInt32Zero), fastPathBB, slowPathBB) positionAtEnd(takeResBB) - val resultPhi = phi(interfaceTableRecordPtrType) + val resultPhi = phi(pointerType(runtime.interfaceTableRecordType)) appendingTo(fastPathBB) { val fastValue = fastPath() br(takeResBB) @@ -260,7 +259,7 @@ internal object VirtualTablesLookup { // Essentially: typeInfo.itable[place(interfaceId)].id == interfaceId val interfaceId = dstHierarchyInfo.interfaceId val interfaceTableRecord = getInterfaceTableRecord(objTypeInfo, interfaceId) - icmpEq(load(llvm.int32Type, structGep(interfaceTableRecord, 0 /* id */)), llvm.int32(interfaceId)) + icmpEq(load(structGep(interfaceTableRecord, 0 /* id */)), llvm.int32(interfaceId)) } } @@ -278,26 +277,23 @@ internal object VirtualTablesLookup { val canCallViaVtable = !owner.isInterface val layoutBuilder = generationState.context.getLayoutBuilder(owner) - val functionPtrType = pointerType(codegen.getLlvmFunctionType(irFunction)) - val functionPtrPtrType = pointerType(functionPtrType) val llvmMethod = when { canCallViaVtable -> { val index = layoutBuilder.vtableIndex(irFunction) val vtablePlace = gep(typeInfoPtr, llvm.int32(1)) // typeInfoPtr + 1 val vtable = bitcast(llvm.int8PtrPtrType, vtablePlace) val slot = gep(vtable, llvm.int32(index)) - load(functionPtrType, bitcast(functionPtrPtrType, slot)) + load(slot) } else -> { // Essentially: typeInfo.itable[place(interfaceId)].vtable[method] val itablePlace = layoutBuilder.itablePlace(irFunction) val interfaceTableRecord = getInterfaceTableRecord(typeInfoPtr, itablePlace.interfaceId) - val vtable = load(llvm.int8PtrPtrType, structGep(interfaceTableRecord, 2 /* vtable */)) - val slot = gep(vtable, llvm.int32(itablePlace.methodIndex)) - load(functionPtrType, bitcast(functionPtrPtrType, slot)) + load(gep(load(structGep(interfaceTableRecord, 2 /* vtable */)), llvm.int32(itablePlace.methodIndex))) } } + val functionPtrType = pointerType(codegen.getLlvmFunctionType(irFunction)) return LlvmCallable( bitcast(functionPtrType, llvmMethod), LlvmFunctionSignature(irFunction, this) @@ -711,7 +707,10 @@ internal abstract class FunctionGenerationContext( fun param(index: Int): LLVMValueRef = function.param(index) - private fun applyMemoryOrderAndAlignment(value: LLVMValueRef, memoryOrder: LLVMAtomicOrdering?, alignment: Int?): LLVMValueRef { + fun load(address: LLVMValueRef, name: String = "", + memoryOrder: LLVMAtomicOrdering? = null, alignment: Int? = null + ): LLVMValueRef { + val value = LLVMBuildLoad(builder, address, name)!! memoryOrder?.let { LLVMSetOrdering(value, it) } alignment?.let { LLVMSetAlignment(value, it) } // Use loadSlot() API for that. @@ -719,12 +718,6 @@ internal abstract class FunctionGenerationContext( return value } - fun load(type: LLVMTypeRef, address: LLVMValueRef, name: String = "", - memoryOrder: LLVMAtomicOrdering? = null, alignment: Int? = null - ): LLVMValueRef { - return applyMemoryOrderAndAlignment(LLVMBuildLoad2(builder, type, address, name)!!, memoryOrder, alignment) - } - fun loadSlot(address: LLVMValueRef, isVar: Boolean, resultSlot: LLVMValueRef? = null, name: String = "", memoryOrder: LLVMAtomicOrdering? = null, alignment: Int? = null): LLVMValueRef { val value = LLVMBuildLoad(builder, address, name)!! @@ -1281,14 +1274,13 @@ internal abstract class FunctionGenerationContext( LLVMAtomicOrdering.LLVMAtomicOrderingAcquire } - // TODO: Get rid of the bitcast here by supplying the type in the GEP above. - val typeInfoOrMetaPtrRaw = bitcast(pointerType(codegen.intPtrType), typeInfoOrMetaPtr) - val typeInfoOrMetaWithFlags = load(codegen.intPtrType, typeInfoOrMetaPtrRaw, memoryOrder = memoryOrder) + val typeInfoOrMetaWithFlags = load(typeInfoOrMetaPtr, memoryOrder = memoryOrder) // Clear two lower bits. - val typeInfoOrMetaRaw = and(typeInfoOrMetaWithFlags, codegen.immTypeInfoMask) + val typeInfoOrMetaWithFlagsRaw = ptrToInt(typeInfoOrMetaWithFlags, codegen.intPtrType) + val typeInfoOrMetaRaw = and(typeInfoOrMetaWithFlagsRaw, codegen.immTypeInfoMask) val typeInfoOrMeta = intToPtr(typeInfoOrMetaRaw, kTypeInfoPtr) val typeInfoPtrPtr = structGep(typeInfoOrMeta, 0 /* typeInfo */) - return load(codegen.kTypeInfoPtr, typeInfoPtrPtr, memoryOrder = LLVMAtomicOrdering.LLVMAtomicOrderingMonotonic) + return load(typeInfoPtrPtr, memoryOrder = LLVMAtomicOrdering.LLVMAtomicOrderingMonotonic) } @Suppress("UNUSED_PARAMETER") @@ -1338,9 +1330,9 @@ internal abstract class FunctionGenerationContext( } val classInfo = codegen.kotlinObjCClassInfo(irClass) - val classPointerGlobal = load(llvm.int8PtrPtrType, structGep(classInfo, KotlinObjCClassInfoGenerator.createdClassFieldIndex)) + val classPointerGlobal = load(structGep(classInfo, KotlinObjCClassInfoGenerator.createdClassFieldIndex)) - val storedClass = this.load(llvm.int8PtrType, classPointerGlobal) + val storedClass = this.load(classPointerGlobal) val storedClassIsNotNull = this.icmpNe(storedClass, llvm.kNullInt8Ptr) @@ -1354,7 +1346,7 @@ internal abstract class FunctionGenerationContext( } } - private fun getObjCClass(binaryName: String) = load(llvm.int8PtrType, codegen.objCDataGenerator!!.genClassRef(binaryName).llvm) + private fun getObjCClass(binaryName: String) = load(codegen.objCDataGenerator!!.genClassRef(binaryName).llvm) fun getObjCClassFromNativeRuntime(binaryName: String): LLVMValueRef { generationState.dependenciesTracker.addNativeRuntime() diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IntrinsicGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IntrinsicGenerator.kt index ec1a7142126..8185471ecc9 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IntrinsicGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IntrinsicGenerator.kt @@ -480,7 +480,7 @@ internal class IntrinsicGenerator(private val environment: IntrinsicGeneratorEnv val pointerType = pointerType(callSite.llvmReturnType) val rawPointer = args.last() val pointer = bitcast(pointerType, rawPointer) - return load(callSite.llvmReturnType, pointer) + return load(pointer) } private fun FunctionGenerationContext.emitWritePrimitive(callSite: IrCall, args: List): LLVMValueRef { @@ -509,7 +509,7 @@ internal class IntrinsicGenerator(private val environment: IntrinsicGeneratorEnv val bitsWithPaddingType = LLVMIntTypeInContext(llvm.llvmContext, bitsWithPaddingNum)!! val bitsWithPaddingPtr = bitcast(pointerType(bitsWithPaddingType), gep(ptr, llvm.int64(offset / 8))) - val bitsWithPadding = load(bitsWithPaddingType, bitsWithPaddingPtr).setUnaligned() + val bitsWithPadding = load(bitsWithPaddingPtr).setUnaligned() val bits = shr( shl(bitsWithPadding, suffixBitsNum), @@ -558,7 +558,7 @@ internal class IntrinsicGenerator(private val environment: IntrinsicGeneratorEnv val bitsToStore = if (prefixBitsNum == 0 && suffixBitsNum == 0) { bits } else { - val previousValue = load(bitsWithPaddingType, bitsWithPaddingPtr).setUnaligned() + val previousValue = load(bitsWithPaddingPtr).setUnaligned() val preservedBits = and(previousValue, preservedBitsMask) val bitsWithPadding = shl(zext(bits, bitsWithPaddingType), prefixBitsNum) diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt index f4c8c6a6958..54d7a5adc83 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt @@ -1873,9 +1873,11 @@ internal class CodeGeneratorVisitor( //-------------------------------------------------------------------------// private fun fieldPtrOfClass(thisPtr: LLVMValueRef, value: IrField): LLVMValueRef { val fieldInfo = generationState.llvmDeclarations.forField(value) - val classBodyType = fieldInfo.classBodyType - val typedBodyPtr = functionGenerationContext.bitcast(pointerType(classBodyType), thisPtr) - val fieldPtr = LLVMBuildStructGEP2(functionGenerationContext.builder, classBodyType, typedBodyPtr, fieldInfo.index, "") + + val typePtr = pointerType(fieldInfo.classBodyType) + + val typedBodyPtr = functionGenerationContext.bitcast(typePtr, thisPtr) + val fieldPtr = LLVMBuildStructGEP(functionGenerationContext.builder, typedBodyPtr, fieldInfo.index, "") return fieldPtr!! } @@ -2505,7 +2507,7 @@ internal class CodeGeneratorVisitor( val bbExit = basicBlock("label_continue", null) moveBlockAfterEntry(bbExit) moveBlockAfterEntry(bbInit) - val state = load(llvm.int32Type, statePtr, memoryOrder = LLVMAtomicOrdering.LLVMAtomicOrderingAcquire) + val state = load(statePtr, memoryOrder = LLVMAtomicOrdering.LLVMAtomicOrderingAcquire) condBr(icmpEq(state, llvm.int32(FILE_INITIALIZED)), bbExit, bbInit) positionAtEnd(bbInit) call(llvm.callInitGlobalPossiblyLock, listOf(statePtr, initializerPtr), @@ -2527,13 +2529,13 @@ internal class CodeGeneratorVisitor( moveBlockAfterEntry(bbExit) moveBlockAfterEntry(bbCheckLocalState) moveBlockAfterEntry(bbInit) - val globalState = load(llvm.int32Type, globalStatePtr) + val globalState = load(globalStatePtr) LLVMSetVolatile(globalState, 1) // Make sure we're not in the middle of global initializer invocation - // thread locals can be initialized only after all shared globals have been initialized. condBr(icmpNe(globalState, llvm.int32(FILE_INITIALIZED)), bbExit, bbCheckLocalState) positionAtEnd(bbCheckLocalState) - condBr(icmpNe(load(llvm.int32Type, localStatePtr), llvm.int32(FILE_INITIALIZED)), bbInit, bbExit) + condBr(icmpNe(load(localStatePtr), llvm.int32(FILE_INITIALIZED)), bbInit, bbExit) positionAtEnd(bbInit) call(llvm.callInitThreadLocal, listOf(globalStatePtr, localStatePtr, initializerPtr), exceptionHandler = currentCodeContext.exceptionHandler) @@ -2551,7 +2553,7 @@ internal class CodeGeneratorVisitor( val bbExit = basicBlock("label_continue", null) moveBlockAfterEntry(bbExit) moveBlockAfterEntry(bbInit) - condBr(icmpEq(load(llvm.int32Type, statePtr), llvm.int32(FILE_INITIALIZED)), bbExit, bbInit) + condBr(icmpEq(load(statePtr), llvm.int32(FILE_INITIALIZED)), bbExit, bbInit) positionAtEnd(bbInit) call(llvm.callInitThreadLocal, listOf(llvm.kNullInt32Ptr, statePtr, initializerPtr), exceptionHandler = currentCodeContext.exceptionHandler) diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objc/ObjCCodeGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objc/ObjCCodeGenerator.kt index bd3f3254bec..08d7a3baff3 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objc/ObjCCodeGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objc/ObjCCodeGenerator.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.backend.konan.llvm.objc import kotlinx.cinterop.signExtend import kotlinx.cinterop.toCValues -import llvm.LLVMGetElementType import llvm.LLVMGetInlineAsm import llvm.LLVMInlineAsmDialect import llvm.LLVMValueRef @@ -25,7 +24,7 @@ internal open class ObjCCodeGenerator(val codegen: CodeGenerator) { fun FunctionGenerationContext.genGetLinkedClass(name: String): LLVMValueRef { val classRef = dataGenerator.genClassRef(name) - return load(llvm.int8PtrType, classRef.llvm) + return load(classRef.llvm) } private val objcMsgSend = llvm.externalNativeRuntimeFunction( @@ -89,6 +88,5 @@ internal open class ObjCCodeGenerator(val codegen: CodeGenerator) { internal fun FunctionGenerationContext.genObjCSelector(selector: String): LLVMValueRef { val selectorRef = codegen.objCDataGenerator!!.genSelectorRef(selector) // TODO: clang emits it with `invariant.load` metadata. - // TODO: Propagate the type here without using the typed pointer. - return load(LLVMGetElementType(selectorRef.llvmType)!!, selectorRef.llvm) + return load(selectorRef.llvm) } \ No newline at end of file diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/BlockPointerSupport.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/BlockPointerSupport.kt index a0b1aa5bbbb..09315354d20 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/BlockPointerSupport.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/BlockPointerSupport.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.backend.konan.llvm.objcexport import llvm.LLVMLinkage +import llvm.LLVMSetLinkage import llvm.LLVMStoreSizeOfType import llvm.LLVMValueRef import org.jetbrains.kotlin.backend.konan.llvm.* @@ -125,9 +126,8 @@ private fun FunctionGenerationContext.loadBlockInvoke( ): LlvmCallable { val invokePtr = structGep(bitcast(pointerType(codegen.runtime.blockLiteralType), blockPtr), 3) val signature = bridge.blockType.toBlockInvokeLlvmType(llvm) - val functionPointerType = pointerType(signature.llvmFunctionType) - val functionPointer = load(functionPointerType, bitcast(pointerType(functionPointerType), invokePtr)) - return LlvmCallable(functionPointer, signature) + + return LlvmCallable(bitcast(pointerType(signature.llvmFunctionType), load(invokePtr)), signature) } private fun FunctionGenerationContext.allocInstanceWithAssociatedObject( diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt index 76c83804cd2..de7630ecfb8 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.backend.konan.llvm.objcexport +import kotlinx.cinterop.toCValues import kotlinx.cinterop.toKString import llvm.* import org.jetbrains.kotlin.backend.common.lower.coroutines.getOrCreateFunctionWithContinuationStub @@ -1286,7 +1287,7 @@ private fun ObjCExportCodeGenerator.generateKotlinToObjCBridge( assert(baseMethod.symbol !is IrConstructorSymbol) fun rethrow() { - val error = load(llvm.int8PtrType, errorOutPtr!!) + val error = load(errorOutPtr!!) val exception = callFromBridge( llvm.Kotlin_ObjCExport_NSErrorAsException, listOf(error), @@ -1325,7 +1326,7 @@ private fun ObjCExportCodeGenerator.generateKotlinToObjCBridge( is MethodBridge.ReturnValue.WithError.ZeroForError -> { if (returnBridge.successMayBeZero) { - val error = load(llvm.int8PtrType, errorOutPtr!!) + val error = load(errorOutPtr!!) ifThen(icmpNe(error, llvm.kNullInt8Ptr)) { // error is not null, so targetResult should be null => no need for objc_release on it. rethrow()