diff --git a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2NativeCompilerArguments.kt b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2NativeCompilerArguments.kt index 897184d773e..3a33033f735 100644 --- a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2NativeCompilerArguments.kt +++ b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2NativeCompilerArguments.kt @@ -391,9 +391,6 @@ class K2NativeCompilerArguments : CommonCompilerArguments() { @Argument(value = "-Xomit-framework-binary", description = "Omit binary when compiling framework") var omitFrameworkBinary: Boolean = false - @Argument(value = "-Xforce-compiler-driver", description = "Force compiler to use specific compiler driver: static or dynamic") - var forceCompilerDriver: String? = null - override fun configureAnalysisFlags(collector: MessageCollector, languageVersion: LanguageVersion): MutableMap, Any> = super.configureAnalysisFlags(collector, languageVersion).also { val optInList = it[AnalysisFlags.optIn] as List<*> diff --git a/kotlin-native/backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/K2Native.kt b/kotlin-native/backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/K2Native.kt index a6159f1986d..0fe71100ca7 100644 --- a/kotlin-native/backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/K2Native.kt +++ b/kotlin-native/backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/K2Native.kt @@ -67,9 +67,6 @@ class K2Native : CLICompiler() { messageCollector.report(ERROR, "K2 does not support Native target right now") return ExitCode.COMPILATION_ERROR } - // TODO: Should be either of two, or PHASE_CONFIG will go away with the old driver. - // TODO: -Xlist-phases does not work correctly for now. - configuration.put(CLIConfigurationKeys.PHASE_CONFIG, createPhaseConfig(toplevelPhaseErased, arguments, messageCollector)) configuration.put(CLIConfigurationKeys.FLEXIBLE_PHASE_CONFIG, createFlexiblePhaseConfig(arguments)) @@ -369,7 +366,6 @@ class K2Native : CLICompiler() { arguments.testDumpOutputPath?.let { put(TEST_DUMP_OUTPUT_PATH, it) } put(PARTIAL_LINKAGE, arguments.partialLinkage) put(OMIT_FRAMEWORK_BINARY, arguments.omitFrameworkBinary) - putIfNotNull(FORCE_COMPILER_DRIVER, arguments.forceCompilerDriver) } } } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/CompilerOutput.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/CompilerOutput.kt index d8bf047c4c7..29e22e48d16 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/CompilerOutput.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/CompilerOutput.kt @@ -204,87 +204,6 @@ internal fun linkBitcodeDependencies(generationState: NativeGenerationState) { } -// TODO: Remove this function after dynamic driver is complete. -internal fun produceOutput(generationState: NativeGenerationState) { - val context = generationState.context - val config = context.config - val tempFiles = generationState.tempFiles - val produce = config.produce - if (produce == CompilerOutputKind.FRAMEWORK) { - generationState.objCExport.produceFrameworkInterface() - if (config.omitFrameworkBinary) { - // Compiler does not compile anything in this mode, so return early. - return - } - } - when (produce) { - CompilerOutputKind.STATIC, - CompilerOutputKind.DYNAMIC, - CompilerOutputKind.FRAMEWORK, - CompilerOutputKind.DYNAMIC_CACHE, - CompilerOutputKind.STATIC_CACHE, - CompilerOutputKind.PROGRAM -> { - val output = tempFiles.nativeBinaryFileName - generationState.bitcodeFileName = output - // Insert `_main` after pipeline so we won't worry about optimizations - // corrupting entry point. - insertAliasToEntryPoint(generationState) - LLVMWriteBitcodeToFile(generationState.llvm.module, output) - } - CompilerOutputKind.LIBRARY -> { - val nopack = config.configuration.getBoolean(KonanConfigKeys.NOPACK) - val output = generationState.outputFiles.klibOutputFileName(!nopack) - val libraryName = config.moduleId - val shortLibraryName = config.shortModuleName - val neededLibraries = context.librariesWithDependencies - val abiVersion = KotlinAbiVersion.CURRENT - val compilerVersion = CompilerVersion.CURRENT.toString() - val libraryVersion = config.configuration.get(KonanConfigKeys.LIBRARY_VERSION) - val metadataVersion = KlibMetadataVersion.INSTANCE.toString() - val irVersion = KlibIrVersion.INSTANCE.toString() - val versions = KotlinLibraryVersioning( - abiVersion = abiVersion, - libraryVersion = libraryVersion, - compilerVersion = compilerVersion, - metadataVersion = metadataVersion, - irVersion = irVersion - ) - val target = config.target - val manifestProperties = config.manifestProperties - - if (!nopack) { - val suffix = config.produce.suffix(target) - if (!output.endsWith(suffix)) { - error("please specify correct output: packed: ${!nopack}, $output$suffix") - } - } - - val library = buildLibrary( - config.nativeLibraries, - config.includeBinaries, - neededLibraries, - context.serializedMetadata!!, - context.serializedIr, - versions, - target, - output, - libraryName, - nopack, - shortLibraryName, - manifestProperties, - context.dataFlowGraph) - - generationState.bitcodeFileName = library.mainBitcodeFileName - } - CompilerOutputKind.BITCODE -> { - val output = generationState.outputFile - generationState.bitcodeFileName = output - LLVMWriteBitcodeToFile(generationState.llvm.module, output) - } - else -> error("not supported: $produce") - } -} - private fun parseAndLinkBitcodeFile(generationState: NativeGenerationState, llvmModule: LLVMModuleRef, path: String) { val parsedModule = parseBitcodeFile(generationState.llvmContext, path) if (!generationState.shouldUseDebugInfoFromNativeLibs()) { diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Context.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Context.kt index ce01a8041c1..5663580b27d 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Context.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Context.kt @@ -10,7 +10,6 @@ import org.jetbrains.kotlin.backend.common.DefaultDelegateFactory import org.jetbrains.kotlin.backend.common.DefaultMapping import org.jetbrains.kotlin.backend.common.LoggingContext import org.jetbrains.kotlin.backend.konan.cexport.CAdapterExportedElements -import org.jetbrains.kotlin.backend.konan.cexport.CAdapterGenerator import org.jetbrains.kotlin.backend.konan.descriptors.BridgeDirections import org.jetbrains.kotlin.backend.konan.descriptors.ClassLayoutBuilder import org.jetbrains.kotlin.backend.konan.descriptors.GlobalHierarchyAnalysisResult @@ -68,7 +67,6 @@ internal class NativeMapping : DefaultMapping() { internal class Context( config: KonanConfig, val environment: KotlinCoreEnvironment, - val frontendServices: FrontendServices, override var bindingContext: BindingContext, val moduleDescriptor: ModuleDescriptor, ) : KonanBackendContext(config), PsiToIrContext { @@ -86,9 +84,6 @@ internal class Context( } } - /** - * Valid from [createSymbolTablePhase] until [destroySymbolTablePhase]. - */ override var symbolTable: SymbolTable? = null lateinit var cAdapterExportedElements: CAdapterExportedElements @@ -109,12 +104,6 @@ internal class Context( // generationStates at the same time. lateinit var generationState: NativeGenerationState - fun disposeGenerationState() { - if (::generationState.isInitialized) generationState.dispose() - } - - val phaseConfig = config.phaseConfig - val innerClassesSupport by lazy { InnerClassesSupport(mapping, irFactory) } val bridgesSupport by lazy { BridgesSupport(mapping, irBuiltIns, irFactory) } val inlineFunctionsSupport by lazy { InlineFunctionsSupport(mapping) } @@ -143,13 +132,6 @@ internal class Context( lateinit var globalHierarchyAnalysisResult: GlobalHierarchyAnalysisResult - // We serialize untouched descriptor tree and IR. - // But we have to wait until the code generation phase, - // to dump this information into generated file. - var serializedMetadata: SerializedMetadata? = null - var serializedIr: SerializedIrModule? = null - var dataFlowGraph: ByteArray? = null - val librariesWithDependencies by lazy { config.librariesWithDependencies(moduleDescriptor) } @@ -190,10 +172,6 @@ internal class Context( lateinit var library: KonanLibraryLayout - fun separator(title: String) { - println("\n\n--- ${title} ----------------------\n") - } - fun verifyBitCode() { if (::generationState.isInitialized) generationState.verifyBitCode() diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfig.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfig.kt index a161c68b570..91c4715f40d 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfig.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfig.kt @@ -47,7 +47,6 @@ class KonanConfig(val project: Project, val configuration: CompilerConfiguration internal val targetManager = platformManager.targetManager(configuration.get(KonanConfigKeys.TARGET)) internal val target = targetManager.target val targetHasAddressDependency get() = target.hasAddressDependencyInMemoryModel() - internal val phaseConfig = configuration.get(CLIConfigurationKeys.PHASE_CONFIG)!! internal val flexiblePhaseConfig = configuration.get(CLIConfigurationKeys.FLEXIBLE_PHASE_CONFIG)!! // TODO: debug info generation mode and debug/release variant selection probably requires some refactoring. diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfigurationKeys.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfigurationKeys.kt index 08644118654..e0c8a8fc8a4 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfigurationKeys.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfigurationKeys.kt @@ -157,7 +157,6 @@ class KonanConfigKeys { val PARTIAL_LINKAGE: CompilerConfigurationKey = CompilerConfigurationKey.create("allows some symbols in klibs be missed") val TEST_DUMP_OUTPUT_PATH: CompilerConfigurationKey = CompilerConfigurationKey.create("path to a file to dump the list of all available tests") val OMIT_FRAMEWORK_BINARY: CompilerConfigurationKey = CompilerConfigurationKey.create("do not generate binary in framework") - val FORCE_COMPILER_DRIVER: CompilerConfigurationKey = CompilerConfigurationKey.create("explicitly pick compiler driver") } } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanDriver.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanDriver.kt index 6867940e3e2..1ad7ee6173b 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanDriver.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanDriver.kt @@ -8,9 +8,7 @@ package org.jetbrains.kotlin.backend.konan import com.intellij.openapi.project.Project import org.jetbrains.kotlin.backend.common.serialization.codedInputStream import org.jetbrains.kotlin.backend.common.serialization.proto.IrFile -import org.jetbrains.kotlin.backend.konan.driver.CompilerDriver import org.jetbrains.kotlin.backend.konan.driver.DynamicCompilerDriver -import org.jetbrains.kotlin.backend.konan.driver.StaticCompilerDriver import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.konan.file.File @@ -35,10 +33,15 @@ class KonanDriver(val project: Project, val environment: KotlinCoreEnvironment, configuration.put(KonanConfigKeys.MAKE_PER_FILE_CACHE, true) configuration.put(KonanConfigKeys.FILES_TO_CACHE, fileNames) } - val konanConfig = KonanConfig(project, configuration) + + if (configuration.get(KonanConfigKeys.LIST_TARGETS) == true) { + konanConfig.targetManager.list() + } + if (konanConfig.infoArgsOnly) return + ensureModuleName(konanConfig) - pickCompilerDriver(konanConfig).run(konanConfig, environment) + DynamicCompilerDriver().run(konanConfig, environment) } private fun ensureModuleName(config: KonanConfig) { @@ -52,20 +55,4 @@ class KonanDriver(val project: Project, val environment: KotlinCoreEnvironment, } } } - - private fun pickCompilerDriver(config: KonanConfig): CompilerDriver { - config.configuration[KonanConfigKeys.FORCE_COMPILER_DRIVER]?.let { - return when (it) { - "dynamic" -> DynamicCompilerDriver() - "static" -> StaticCompilerDriver() - else -> error("Unknown compiler driver. Possible values: dynamic, static") - } - } - // Dynamic driver is WIP, so it might not support all possible configurations. - return if (DynamicCompilerDriver.supportsConfig(config)) { - DynamicCompilerDriver() - } else { - StaticCompilerDriver() - } - } } \ No newline at end of file diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ToplevelPhases.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ToplevelPhases.kt index ceb1f07fbb8..11deaa20d8c 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ToplevelPhases.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ToplevelPhases.kt @@ -9,33 +9,15 @@ import org.jetbrains.kotlin.backend.common.IrValidator import org.jetbrains.kotlin.backend.common.IrValidatorConfig import org.jetbrains.kotlin.backend.common.checkDeclarationParents import org.jetbrains.kotlin.backend.common.phaser.* -import org.jetbrains.kotlin.backend.common.serialization.CompatibilityMode -import org.jetbrains.kotlin.backend.common.serialization.metadata.KlibMetadataMonolithicSerializer -import org.jetbrains.kotlin.backend.konan.cexport.CAdapterExportedElements -import org.jetbrains.kotlin.backend.konan.cexport.CAdapterGenerator -import org.jetbrains.kotlin.backend.konan.cexport.CAdapterTypeTranslator import org.jetbrains.kotlin.backend.konan.descriptors.isFromInteropLibrary -import org.jetbrains.kotlin.backend.konan.driver.phases.PsiToIrInput import org.jetbrains.kotlin.backend.konan.llvm.* import org.jetbrains.kotlin.backend.konan.lower.CacheInfoBuilder -import org.jetbrains.kotlin.backend.konan.lower.ExpectToActualDefaultValueCopier import org.jetbrains.kotlin.backend.konan.lower.SamSuperTypesChecker -import org.jetbrains.kotlin.backend.konan.objcexport.createCodeSpec -import org.jetbrains.kotlin.backend.konan.objcexport.produceObjCExportInterface -import org.jetbrains.kotlin.backend.konan.serialization.KonanIdSignaturer -import org.jetbrains.kotlin.backend.konan.serialization.KonanIrModuleSerializer -import org.jetbrains.kotlin.backend.konan.serialization.KonanManglerDesc -import org.jetbrains.kotlin.config.CommonConfigurationKeys -import org.jetbrains.kotlin.config.languageVersionSettings import org.jetbrains.kotlin.ir.declarations.IrFile import org.jetbrains.kotlin.ir.declarations.IrModuleFragment -import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl -import org.jetbrains.kotlin.ir.declarations.path import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.konan.target.CompilerOutputKind import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.resolve.BindingContext -import org.jetbrains.kotlin.resolve.CleanableBindingContext internal fun moduleValidationCallback(state: ActionState, module: IrModuleFragment, context: Context) { if (!context.config.needVerifyIr) return @@ -82,54 +64,6 @@ internal fun konanUnitPhase( op: Context.() -> Unit ) = namedOpUnitPhase(name, description, prerequisite, op) -internal val createSymbolTablePhase = konanUnitPhase( - op = { - this.symbolTable = SymbolTable(KonanIdSignaturer(KonanManglerDesc), IrFactoryImpl) - }, - name = "CreateSymbolTable", - description = "Create SymbolTable" -) - -internal val objCExportPhase = konanUnitPhase( - op = { - objCExportedInterface = when { - !config.target.family.isAppleFamily -> null - config.produce != CompilerOutputKind.FRAMEWORK -> null - else -> produceObjCExportInterface(this, this.moduleDescriptor, this.frontendServices) - } - objCExportCodeSpec = objCExportedInterface?.createCodeSpec(symbolTable!!) - }, - name = "ObjCExport", - description = "Objective-C header generation", - prerequisite = setOf(createSymbolTablePhase) -) - -internal val buildCExportsPhase = konanUnitPhase( - op = { - val prefix = config.fullExportedNamePrefix.replace("-|\\.".toRegex(), "_") - val cAdapterTypeTranslator = CAdapterTypeTranslator(prefix, this.builtIns) - this.cAdapterExportedElements = CAdapterGenerator(this, cAdapterTypeTranslator).buildExports(this.moduleDescriptor) - }, - name = "BuildCExports", - description = "Build C exports", - prerequisite = setOf(createSymbolTablePhase) -) - -internal val psiToIrPhase = konanUnitPhase( - op = { - val input = PsiToIrInput(moduleDescriptor, environment, isProducingLibrary = config.produce == CompilerOutputKind.LIBRARY) - val psiToIrOutput = this.psiToIr(input, useLinkerWhenProducingLibrary = false) - this.populateAfterPsiToIr(psiToIrOutput) - val originalBindingContext = bindingContext as? CleanableBindingContext - ?: error("BindingContext should be cleanable in K/N IR to avoid leaking memory: $bindingContext") - originalBindingContext.clear() - this.bindingContext = BindingContext.EMPTY - }, - name = "Psi2Ir", - description = "Psi to IR conversion and klib linkage", - prerequisite = setOf(createSymbolTablePhase) -) - internal val buildAdditionalCacheInfoPhase = konanUnitPhase( op = { val module = irModules[config.libraryToCache!!.klib.libraryName] @@ -147,26 +81,6 @@ internal val buildAdditionalCacheInfoPhase = konanUnitPhase( // prerequisite = setOf(psiToIrPhase) ) -internal val destroySymbolTablePhase = konanUnitPhase( - op = { - this.symbolTable = null // TODO: invalidate symbolTable itself. - }, - name = "DestroySymbolTable", - description = "Destroy SymbolTable", - prerequisite = setOf(createSymbolTablePhase) -) - -// TODO: We copy default value expressions from expects to actuals before IR serialization, -// because the current infrastructure doesn't allow us to get them at deserialization stage. -// That requires some design and implementation work. -internal val copyDefaultValuesToActualPhase = konanUnitPhase( - op = { - ExpectToActualDefaultValueCopier(irModule!!).process() - }, - name = "CopyDefaultValuesToActual", - description = "Copy default values from expect to actual declarations" -) - /* * Sometimes psi2ir produces IR with non-trivial variance in super types of SAM conversions (this is a language design issue). * Earlier this was solved with just erasing all such variances but this might lead to some other hard to debug problems, @@ -194,31 +108,6 @@ internal val checkSamSuperTypesPhase = konanUnitPhase( description = "Check SAM conversions super types" ) -internal val serializerPhase = konanUnitPhase( - op = { - val expectActualLinker = config.configuration.get(CommonConfigurationKeys.EXPECT_ACTUAL_LINKER) ?: false - val messageLogger = config.configuration.get(IrMessageLogger.IR_MESSAGE_LOGGER) ?: IrMessageLogger.None - val relativePathBase = config.configuration.get(CommonConfigurationKeys.KLIB_RELATIVE_PATH_BASES) ?: emptyList() - val normalizeAbsolutePaths = config.configuration.get(CommonConfigurationKeys.KLIB_NORMALIZE_ABSOLUTE_PATH) ?: false - - serializedIr = irModule?.let { ir -> - KonanIrModuleSerializer( - messageLogger, ir.irBuiltins, expectDescriptorToSymbol, skipExpects = !expectActualLinker, compatibilityMode = CompatibilityMode.CURRENT, normalizeAbsolutePaths = normalizeAbsolutePaths, sourceBaseDirs = relativePathBase - ).serializedIrModule(ir) - } - - val serializer = KlibMetadataMonolithicSerializer( - this.config.configuration.languageVersionSettings, - config.configuration.get(CommonConfigurationKeys.METADATA_VERSION)!!, - config.project, - exportKDoc = this.shouldExportKDoc(), - !expectActualLinker, includeOnlyModuleContent = true) - serializedMetadata = serializer.serializeModule(moduleDescriptor) - }, - name = "Serializer", - description = "Serialize descriptor tree and inline IR bodies" -) - internal val saveAdditionalCacheInfoPhase = konanUnitPhase( op = { CacheStorage(generationState).saveAdditionalCacheInfo() }, name = "SaveAdditionalCacheInfo", @@ -349,42 +238,6 @@ internal val dependenciesLowerPhase = SameTypeNamedCompilerPhase( } }) -internal val umbrellaCompilation = SameTypeNamedCompilerPhase( - name = "UmbrellaCompilation", - description = "A batched compilation with shared FE and ME phases", - prerequisite = emptySet(), - lower = object : CompilerPhase { - override fun invoke(phaseConfig: PhaseConfigurationService, phaserState: PhaserState, context: Context, input: Unit) { - val module = context.irModules[context.config.libraryToCache!!.klib.libraryName] - ?: error("No module for the library being cached: ${context.config.libraryToCache!!.klib.libraryName}") - - val files = module.files.toList() - module.files.clear() - val functionInterfaceFiles = files.filter { it.isFunctionInterfaceFile } - - for (file in files) { - if (file.isFunctionInterfaceFile) continue - - context.generationState = NativeGenerationState( - context.config, - context, - CacheDeserializationStrategy.SingleFile(file.path, file.fqName.asString()) - ) - - module.files += file - if (context.generationState.shouldDefineFunctionClasses) - module.files += functionInterfaceFiles - - entireBackend.invoke(phaseConfig, phaserState, context, Unit) - - module.files.clear() - context.irModule!!.files.clear() // [dependenciesLowerPhase] puts all files to [context.irModule] for codegen. - } - - module.files += files - } - }) - internal val entryPointPhase = makeCustomPhase( name = "addEntryPoint", description = "Add entry point for program", @@ -438,96 +291,6 @@ internal val bitcodePostprocessingPhase = SameTypeNamedCompilerPhase( rewriteExternalCallsCheckerGlobals ) -private val backendCodegen = SameTypeNamedCompilerPhase( - name = "Backend codegen", - description = "Backend code generation", - lower = entryPointPhase then - allLoweringsPhase then // Lower current module first. - dependenciesLowerPhase then // Then lower all libraries in topological order. - // With that we guarantee that inline functions are unlowered while being inlined. - bitcodePhase then - verifyBitcodePhase then - printBitcodePhase then - linkBitcodeDependenciesPhase then - bitcodePostprocessingPhase -) - -internal val createGenerationStatePhase = namedUnitPhase( - name = "CreateGenerationState", - description = "Create generation state", - lower = object : CompilerPhase { - override fun invoke(phaseConfig: PhaseConfigurationService, phaserState: PhaserState, context: Context, input: Unit) { - context.generationState = NativeGenerationState(context.config, context, context.config.libraryToCache?.strategy) - } - } -) - -internal val disposeGenerationStatePhase = namedUnitPhase( - name = "DisposeGenerationState", - description = "Dispose generation state", - lower = object : CompilerPhase { - override fun invoke(phaseConfig: PhaseConfigurationService, phaserState: PhaserState, context: Context, input: Unit) { - context.disposeGenerationState() - } - } -) - -private val phasesOverMainModule = SameTypeNamedCompilerPhase( - name = "PhasesOverMainModule", - description = "Phases over main module", - lower = takeFromContext { it.irModule!! } then - specialBackendChecksPhase then - backendCodegen then - unitSink(), - prerequisite = setOf(psiToIrPhase) -) - -private val entireBackend = SameTypeNamedCompilerPhase( - name = "EntireBackend", - description = "Entire backend", - lower = buildAdditionalCacheInfoPhase then - phasesOverMainModule then - saveAdditionalCacheInfoPhase then - produceOutputPhase then - objectFilesPhase then - linkerPhase then - finalizeCachePhase then - disposeGenerationStatePhase -) - -private val middleEnd = SameTypeNamedCompilerPhase( - name = "MiddleEnd", - description = "Build and prepare IR for back end", - lower = createSymbolTablePhase then - objCExportPhase then - buildCExportsPhase then - psiToIrPhase then - destroySymbolTablePhase then - copyDefaultValuesToActualPhase then - checkSamSuperTypesPhase then - serializerPhase then - functionsWithoutBoundCheck -) - -private val singleCompilation = SameTypeNamedCompilerPhase( - name = "SingleCompilation", - description = "Single compilation", - lower = createGenerationStatePhase then - entireBackend -) - -internal val toplevelPhase: CompilerPhase = namedUnitPhase( - name = "Compiler", - description = "The whole compilation process", - lower = middleEnd then - singleCompilation then - umbrellaCompilation -) - -// Have to hide Context as type parameter in order to expose toplevelPhase outside of this module. -val toplevelPhaseErased: CompilerPhase<*, Unit, Unit> - get() = toplevelPhase - internal fun PhaseConfigurationService.disableIf(phase: AnyNamedPhase, condition: Boolean) { if (condition) disable(phase) } @@ -544,19 +307,11 @@ internal fun PhaseConfigurationService.konanPhasesConfig(config: KonanConfig) { // Also see https://youtrack.jetbrains.com/issue/KT-50399 for more details. disable(checkSamSuperTypesPhase) - disableIf(singleCompilation, config.producePerFileCache) - disableUnless(umbrellaCompilation, config.producePerFileCache) - - // Don't serialize anything to a final executable. - disableUnless(serializerPhase, config.produce == CompilerOutputKind.LIBRARY) - disableUnless(entryPointPhase, config.produce == CompilerOutputKind.PROGRAM) disableUnless(buildAdditionalCacheInfoPhase, config.produce.isCache) disableUnless(saveAdditionalCacheInfoPhase, config.produce.isCache) disableUnless(finalizeCachePhase, config.produce.isCache) disableUnless(exportInternalAbiPhase, config.produce.isCache) - disableUnless(buildCExportsPhase, config.produce.isNativeLibrary) disableUnless(functionsWithoutBoundCheck, config.involvesCodegen) - disableUnless(backendCodegen, config.involvesCodegen) disableUnless(checkExternalCallsPhase, getBoolean(KonanConfigKeys.CHECK_EXTERNAL_CALLS)) disableUnless(rewriteExternalCallsCheckerGlobals, getBoolean(KonanConfigKeys.CHECK_EXTERNAL_CALLS)) disableUnless(stringConcatenationTypeNarrowingPhase, config.optimizationsEnabled) @@ -586,12 +341,5 @@ internal fun PhaseConfigurationService.konanPhasesConfig(config: KonanConfig) { disableUnless(removeRedundantSafepointsPhase, config.memoryModel == MemoryModel.EXPERIMENTAL) - - if (config.metadataKlib || config.omitFrameworkBinary) { - disable(psiToIrPhase) - disable(copyDefaultValuesToActualPhase) - disable(phasesOverMainModule) - disable(checkSamSuperTypesPhase) - } } } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/DynamicCompilerDriver.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/DynamicCompilerDriver.kt index e12775c2dda..4316033b5d6 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/DynamicCompilerDriver.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/DynamicCompilerDriver.kt @@ -18,19 +18,6 @@ import org.jetbrains.kotlin.konan.util.usingNativeMemoryAllocator */ internal class DynamicCompilerDriver : CompilerDriver() { - companion object { - fun supportsConfig(config: KonanConfig): Boolean = - config.produce in setOf( - CompilerOutputKind.PROGRAM, - CompilerOutputKind.LIBRARY, - CompilerOutputKind.DYNAMIC_CACHE, - CompilerOutputKind.STATIC_CACHE, - CompilerOutputKind.FRAMEWORK, - CompilerOutputKind.DYNAMIC, - CompilerOutputKind.STATIC, - ) - } - override fun run(config: KonanConfig, environment: KotlinCoreEnvironment) { usingNativeMemoryAllocator { usingJvmCInteropCallbacks { @@ -41,7 +28,7 @@ internal class DynamicCompilerDriver : CompilerDriver() { CompilerOutputKind.STATIC -> produceCLibrary(engine, config, environment) CompilerOutputKind.FRAMEWORK -> produceObjCFramework(engine, config, environment) CompilerOutputKind.LIBRARY -> produceKlib(engine, config, environment) - CompilerOutputKind.BITCODE -> error("Dynamic compiler driver does not support `bitcode` output yet.") + CompilerOutputKind.BITCODE -> error("Bitcode output kind is obsolete.") CompilerOutputKind.DYNAMIC_CACHE -> produceBinary(engine, config, environment) CompilerOutputKind.STATIC_CACHE -> produceBinary(engine, config, environment) CompilerOutputKind.PRELIMINARY_CACHE -> TODO() @@ -114,7 +101,6 @@ internal class DynamicCompilerDriver : CompilerDriver() { ) = Context( config, frontendOutput.environment, - frontendOutput.frontendServices, frontendOutput.bindingContext, frontendOutput.moduleDescriptor ).also { diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/StaticCompilerDriver.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/StaticCompilerDriver.kt deleted file mode 100644 index 9d8ba97ba03..00000000000 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/StaticCompilerDriver.kt +++ /dev/null @@ -1,62 +0,0 @@ -/* - * 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.konan.driver - -import kotlinx.cinterop.usingJvmCInteropCallbacks -import org.jetbrains.kotlin.backend.common.phaser.invokeToplevel -import org.jetbrains.kotlin.backend.konan.* -import org.jetbrains.kotlin.backend.konan.driver.phases.FrontendContextImpl -import org.jetbrains.kotlin.backend.konan.driver.phases.FrontendPhase -import org.jetbrains.kotlin.backend.konan.driver.phases.FrontendPhaseOutput -import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment -import org.jetbrains.kotlin.konan.util.usingNativeMemoryAllocator - -/** - * Static compiler uses statically-defined compilation pipeline and a single Context during whole compilation. - * Superseded by [DynamicCompilerDriver] and will be removed once dynamic driver become complete. - */ -internal class StaticCompilerDriver : CompilerDriver() { - override fun run(config: KonanConfig, environment: KotlinCoreEnvironment) { - runTopLevelPhases(config, environment) - } - - private fun runTopLevelPhases(konanConfig: KonanConfig, environment: KotlinCoreEnvironment) { - - val config = konanConfig.configuration - - val targets = konanConfig.targetManager - if (config.get(KonanConfigKeys.LIST_TARGETS) ?: false) { - targets.list() - } - - if (konanConfig.infoArgsOnly) return - - val frontendContext = FrontendContextImpl(konanConfig) - val frontendOutput = FrontendPhase.phaseBody(frontendContext, environment) - if (frontendOutput is FrontendPhaseOutput.ShouldNotGenerateCode) { - return - } - require(frontendOutput is FrontendPhaseOutput.Full) - val context = Context( - konanConfig, - environment, - frontendOutput.frontendServices, - frontendOutput.bindingContext, - frontendOutput.moduleDescriptor, - ) - context.phaseConfig.konanPhasesConfig(konanConfig) // TODO: Wrong place to call it - - usingNativeMemoryAllocator { - usingJvmCInteropCallbacks { - try { - toplevelPhase.invokeToplevel(context.phaseConfig, context, Unit) - } finally { - context.disposeGenerationState() - } - } - } - } -} \ No newline at end of file diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BitcodePhases.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BitcodePhases.kt index 61132540280..c62bd74025f 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BitcodePhases.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BitcodePhases.kt @@ -310,16 +310,6 @@ internal val optimizeTLSDataLoadsPhase = makeKonanModuleOpPhase( op = { context, _ -> removeMultipleThreadDataLoads(context.generationState) } ) -internal val produceOutputPhase = namedUnitPhase( - name = "ProduceOutput", - description = "Produce output", - lower = object : CompilerPhase { - override fun invoke(phaseConfig: PhaseConfigurationService, phaserState: PhaserState, context: Context, input: Unit) { - produceOutput(context.generationState) - } - } -) - internal val removeRedundantSafepointsPhase = makeKonanModuleOpPhase( name = "RemoveRedundantSafepoints", description = "Remove function prologue safepoints inlined to another function",