交叉编译配置

源：Kotlin/Native Target Support

交叉编译允许在一个平台上构建另一个平台的程序。Kotlin/Native 提供强大的交叉编译支持。

支持的目标平台

平台分类

# 查看所有支持的目标
kotlinc-native -list-targets

# 分类
macOS/iOS:
  - macosX64, macosArm64
  - iosArm64, iosX64, iosSimulatorArm64
  - watchosArm32/64, tvosArm64

Linux:
  - linuxX64, linuxArm64, linuxArm32Hfp

Windows:
  - mingwX64, mingwX86

Android:
  - androidNativeArm32/64, androidNativeX86/64

主机-目标矩阵

主机 ↓ / 目标 →	Linux	macOS	iOS	Windows	Android
Linux	✅	❌	❌	✅	✅
macOS	✅	✅	✅	✅	✅
Windows	❌	❌	❌	✅	✅

单目标交叉编译

Linux → Windows

# 在 Linux 上编译 Windows 程序
kotlinc-native -target mingwX64 main.kt -o app.exe

# 需要安装 mingw 工具链
sudo apt install mingw-w64

macOS → iOS

# macOS → iOS 设备
kotlinc-native -target iosArm64 main.kt -o iOSApp

# macOS → iOS 模拟器
kotlinc-native -target iosSimulatorArm64 main.kt -o iOSSimApp

# 生成 Framework
kotlinc-native -produce framework \
    -target iosArm64 \
    MyFramework.kt -o MyFramework

macOS → Linux

# macOS → Linux x64
kotlinc-native -target linuxX64 main.kt -o app_linux

# macOS → Linux ARM64
kotlinc-native -target linuxArm64 main.kt -o app_linux_arm

Gradle 多目标配置

基础多目标

//build.gradle.kts
kotlin {
    // 声明所有目标
    linuxX64()
    linuxArm64()
    macosX64()
    macosArm64()
    mingwX64()
    
    // 源码集配置
    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
            }
        }
        
        val nativeMain by creating {
            dependsOn(commonMain)
        }
        
        // 平台特定源码
        val linuxX64Main by getting {
            dependsOn(nativeMain)
        }
        
        val macosX64Main by getting {
            dependsOn(nativeMain)
        }
    }
}

选择性目标

kotlin {
    // 根据主机平台启用目标
    val hostOs = System.getProperty("os.name")
    val isMingwX64 = hostOs.startsWith("Windows")
    val isLinux = hostOs == "Linux"
    val isMac = hostOs == "Mac OS X"
    
    when {
        isMingwX64 -> {
            mingwX64()
            androidNativeArm64()
        }
        isLinux -> {
            linuxX64()
            linuxArm64()
            mingwX64()  // 交叉编译
            androidNativeArm64()
        }
        isMac -> {
            macosX64()
            macosArm64()
            iosArm64()
            iosSimulatorArm64()
            linuxX64()  // 交叉编译
            mingwX64()  // 交叉编译
        }
    }
}

工具链管理

自动工具链

Kotlin/Native 自动下载所需工具链：

~/.konan/
├── dependencies/
│   ├── clang-llvm-16.0.0/
│   ├── libffi-3.4.2/
│   └── target-sysroot-*-apple-darwin/
├── kotlin-native-prebuilt-*/
└── cache/

自定义工具链

# 指定工具链路径
export KONAN_DATA_DIR=/custom/konan

# 禁用自动下载
kotlinc-native -Xoverride-konan-properties=\
    downloadingEnabled=false \
    main.kt

配置文件

# ~/.konan/konan.properties

# 依赖服务器
dependenciesUrl=https://download.jetbrains.com

# LLVM 发行版
llvmHome.linux_x64=/usr/lib/llvm-16
llvmHome.macos_x64=/usr/local/opt/llvm

# 目标 sysroot
targetSysRoot.ios_arm64=/Applications/Xcode.app/.../iPhoneOS.sdk

平台特定配置

Android Native

kotlin {
    androidNativeArm64 {
        binaries.sharedLib {
            baseName = "native_lib"
            
            // 指定 NDK
            val ndkPath = android.ndkDirectory
            freeCompilerArgs += listOf(
                "-linker-option", "-L$ndkPath/platforms/android-24/arch-arm64/usr/lib"
            )
        }
    }
}

android {
    ndkVersion = "25.2.9519653"
    
    defaultConfig {
        ndk {
            abiFilters += "arm64-v8a"
        }
    }
}

iOS Framework

kotlin {
    val iosTargets = listOf(
        iosArm64(),
        iosSimulatorArm64()
    )
    
    iosTargets.forEach { target ->
        target.binaries.framework {
            baseName = "SharedFramework"
            
            // 导出依赖
            export(project(":shared"))
            
            // Bitcode
            freeCompilerArgs += "-Xembed-bitcode"
            
            // 优化
            if (buildType == NativeBuildType.RELEASE) {
                freeCompilerArgs += listOf("-opt", "-Xlto")
            }
        }
    }
}

// XCFramework 打包
tasks.register("buildXCFramework") {
    dependsOn("linkReleaseFrameworkIosArm64")
    dependsOn("linkReleaseFrameworkIosSimulatorArm64")
    
    doLast {
        exec {
            commandLine("xcodebuild", "-create-xcframework",
                "-framework", "build/bin/iosArm64/releaseFramework/SharedFramework.framework",
                "-framework", "build/bin/iosSimulatorArm64/releaseFramework/SharedFramework.framework",
                "-output", "build/SharedFramework.xcframework"
            )
        }
    }
}

Linux 静态链接

kotlin {
    linuxX64 {
        binaries.executable {
            entryPoint = "main"
            
            // 静态链接 C++ 标准库
            linkerOpts += listOf(
                "-static-libgcc",
                "-static-libstdc++"
            )
            
            // 完全静态（需要 musl）
            // linkerOpts += "-static"
        }
    }
}

CI/CD 配置

GitHub Actions

# .github/workflows/build.yml
name: Multi-Platform Build

on: [push]

jobs:
  build-linux:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - uses: actions/setup-java@v3
        with:
          java-version: '17'
      
      - name: Build Linux Targets
        run: |
          ./gradlew linkReleaseExecutableLinuxX64
          ./gradlew linkReleaseExecutableLinuxArm64
      
      - name: Cross-compile Windows
        run: |
          sudo apt install mingw-w64
          ./gradlew linkReleaseExecutableMingwX64
  
  build-macos:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Build macOS + iOS
        run: |
          ./gradlew linkReleaseExecutableMacosX64
          ./gradlew linkReleaseExecutableMacosArm64
          ./gradlew linkReleaseFrameworkIosArm64
          ./gradlew buildXCFramework
      
      - name: Upload Artifacts
        uses: actions/upload-artifact@v3
        with:
          name: xcframework
          path: build/SharedFramework.xcframework

性能优化

增量编译

kotlin {
    targets.all {
        compilations.all {
            kotlinOptions {
                // 启用增量编译
                incremental = true
            }
        }
    }
}

并行构建

# gradle.properties
kotlin.parallel.tasks.in.project=true
org.gradle.parallel=true
org.gradle.workers.max=4

# 编译器并行
kotlin.native.parallel=true

缓存

# 启用编译器缓存
mkdir -p ~/.konan/cache

# Gradle 配置
kotlin.native.cacheKind=static  # 或 dynamic

---

交叉编译是 Kotlin/Native 的核心优势。通过合理配置，可以在单一开发环境中构建所有目标平台的程序。