mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
c0c9116bd6
EnableCaching should only configure cmake to allow for sccache usage, it should not configure sccache itself in any way. Those configuration options should be deferred into the environment variables that sccache will look for when it starts up.
3341 lines
127 KiB
PowerShell
3341 lines
127 KiB
PowerShell
# Copyright 2020 Saleem Abdulrasool <compnerd@compnerd.org>
|
|
# Copyright 2023 Tristan Labelle <tristan@thebrowser.company>
|
|
|
|
<#
|
|
.SYNOPSIS
|
|
Builds the Swift toolchain, installers, and optionally runs tests.
|
|
|
|
.DESCRIPTION
|
|
This script performs various steps associated with building the Swift toolchain:
|
|
|
|
- Builds the redistributable, SDK, devtools and toolchain binaries and files
|
|
- Builds the msi's and installer executable
|
|
- Creates a mock installation under S:\Program Files and S:\Library for local toolchain use
|
|
- Optionally runs tests for supported projects
|
|
- Optionally stages build artifacts for CI
|
|
|
|
.PARAMETER SourceCache
|
|
The path to a directory where projects contributing to the Swift.
|
|
toolchain have been cloned.
|
|
|
|
.PARAMETER BinaryCache
|
|
The path to a directory where to write build system files and outputs.
|
|
|
|
.PARAMETER ImageRoot
|
|
The path to a directory that mimics a file system image root,
|
|
under which "Library" and "Program Files" subdirectories will be created
|
|
with the files installed by CMake.
|
|
|
|
.PARAMETER CDebugFormat
|
|
The debug information format for C/C++ code: dwarf or codeview.
|
|
|
|
.PARAMETER SwiftDebugFormat
|
|
The debug information format for Swift code: dwarf or codeview.
|
|
|
|
.PARAMETER AndroidAPILevel
|
|
The API Level to target when building the Android SDKs
|
|
|
|
.PARAMETER Android
|
|
When set, build android SDKs.
|
|
|
|
.PARAMETER AndroidSDKs
|
|
An array of architectures for which the Android Swift SDK should be built.
|
|
|
|
.PARAMETER WindowsSDKs
|
|
An array of architectures for which the Windows Swift SDK should be built.
|
|
|
|
.PARAMETER ProductVersion
|
|
The product version to be used when building the installer.
|
|
Supports semantic version strings.
|
|
|
|
.PARAMETER PinnedBuild
|
|
The toolchain snapshot to build the early components with.
|
|
|
|
.PARAMETER PinnedSHA256
|
|
The SHA256 for the pinned toolchain.
|
|
|
|
.PARAMETER PinnedToolchainVariant
|
|
The toolchain variant to use while building the toolchain. Defaults to
|
|
`Asserts`.
|
|
|
|
.PARAMETER AndroidNDKVersion
|
|
The version number of the Android NDK to be used.
|
|
|
|
.PARAMETER WinSDKVersion
|
|
The version number of the Windows SDK to be used.
|
|
Overrides the value resolved by the Visual Studio command prompt.
|
|
If no such Windows SDK is installed, it will be downloaded from nuget.
|
|
|
|
.PARAMETER IncludeDS2
|
|
Include the ds2 remote debug server in the SDK.
|
|
This component is currently only supported in Android builds.
|
|
|
|
.PARAMETER SkipBuild
|
|
If set, does not run the build phase.
|
|
|
|
.PARAMETER SkipPackaging
|
|
If set, skips building the msi's and installer
|
|
|
|
.PARAMETER DebugInfo
|
|
If set, debug information will be generated for the builds.
|
|
|
|
.PARAMETER EnableCaching
|
|
If true, use `sccache` to cache the build rules. Configuration of sccache must be done through
|
|
the environment variables defined by the sccache project.
|
|
|
|
.PARAMETER Clean
|
|
If true, clean non-compiler builds while building.
|
|
|
|
.PARAMETER Test
|
|
An array of names of projects to run tests for.
|
|
'*' runs all tests
|
|
|
|
.PARAMETER Stage
|
|
The path to a directory where built msi's and the installer executable should be staged (for CI).
|
|
|
|
.PARAMETER BuildTo
|
|
The name of a build step after which the script should terminate.
|
|
For example: -BuildTo ToolsSupportCore
|
|
|
|
.PARAMETER ToBatch
|
|
When set, runs the script in a special mode which outputs a listing of command invocations
|
|
in batch file format instead of executing them.
|
|
|
|
.PARAMETER HostArchName
|
|
The architecture where the toolchain will execute.
|
|
|
|
.PARAMETER Variant
|
|
The toolchain variant to build. Defaults to `Asserts`.
|
|
|
|
.PARAMETER FoundationTestConfiguration
|
|
Whether to run swift-foundation and swift-corelibs-foundation tests in a debug or release configuration.
|
|
|
|
.EXAMPLE
|
|
PS> .\Build.ps1
|
|
|
|
.EXAMPLE
|
|
PS> .\Build.ps1 -WindowsSDKs x64 -ProductVersion 1.2.3 -Test foundation,xctest
|
|
#>
|
|
[CmdletBinding(PositionalBinding = $false)]
|
|
param
|
|
(
|
|
[System.IO.FileInfo] $SourceCache = "S:\SourceCache",
|
|
[System.IO.FileInfo] $BinaryCache = "S:\b",
|
|
[System.IO.FileInfo] $ImageRoot = "S:",
|
|
[ValidateSet("codeview", "dwarf")]
|
|
[string] $CDebugFormat = "dwarf",
|
|
[ValidateSet("codeview", "dwarf")]
|
|
[string] $SwiftDebugFormat = "dwarf",
|
|
[ValidateRange(1, 36)]
|
|
[int] $AndroidAPILevel = 28,
|
|
[string[]] $AndroidSDKs = @(),
|
|
[string[]] $WindowsSDKs = @("X64","X86","Arm64"),
|
|
[string] $ProductVersion = "0.0.0",
|
|
[string] $ToolchainIdentifier = $(if ($env:TOOLCHAIN_VERSION) { $env:TOOLCHAIN_VERSION } else { "$env:USERNAME.development" }),
|
|
[string] $PinnedBuild = "",
|
|
[ValidatePattern("^([A-Fa-f0-9]{64}|)$")]
|
|
[string] $PinnedSHA256 = "",
|
|
[string] $PinnedVersion = "",
|
|
[ValidateSet("Asserts", "NoAsserts")]
|
|
[string] $PinnedToolchainVariant = "Asserts",
|
|
[ValidatePattern('^\d+(\.\d+)*$')]
|
|
[string] $PythonVersion = "3.9.10",
|
|
[ValidatePattern("^r(?:[1-9]|[1-9][0-9])(?:[a-z])?$")]
|
|
[string] $AndroidNDKVersion = "r27c",
|
|
[ValidatePattern("^\d+\.\d+\.\d+(?:-\w+)?")]
|
|
[string] $WinSDKVersion = "",
|
|
[switch] $Android = $false,
|
|
[switch] $SkipBuild = $false,
|
|
[switch] $SkipPackaging = $false,
|
|
[switch] $IncludeDS2 = $false,
|
|
[string[]] $Test = @(),
|
|
[string] $Stage = "",
|
|
[ValidateSet("ArgumentParser", "ASN1", "BuildTools", "Certificates", "CMark",
|
|
"Collections", "Compilers", "Crypto", "CURL", "Dispatch", "DocC", "Driver",
|
|
"DS2", "ExperimentalRuntime", "Format", "Foundation", "FoundationMacros",
|
|
"IndexStoreDB", "Inspect", "Installer", "LLBuild", "LLVM", "LMDB",
|
|
"Markdown", "mimalloc", "PackageManager", "PlatformInfoPlist", "RegsGen2",
|
|
"Runtime", "Sanitizers", "SDKSettingsPlist", "SourceKitLSP", "SQLite",
|
|
"System", "Testing", "TestingMacros", "ToolsSupportCore", "XCTest", "XML2",
|
|
"ZLib")]
|
|
[string] $BuildTo = "",
|
|
[ValidateSet("AMD64", "ARM64")]
|
|
[string] $HostArchName = $(if ($env:PROCESSOR_ARCHITEW6432) { $env:PROCESSOR_ARCHITEW6432 } else { $env:PROCESSOR_ARCHITECTURE }),
|
|
[ValidateSet("Asserts", "NoAsserts")]
|
|
[string] $Variant = "Asserts",
|
|
[switch] $Clean,
|
|
[switch] $DebugInfo,
|
|
[switch] $EnableCaching,
|
|
[ValidateSet("debug", "release")]
|
|
[string] $FoundationTestConfiguration = "debug",
|
|
[switch] $Summary,
|
|
[switch] $ToBatch
|
|
)
|
|
|
|
## Prepare the build environment.
|
|
|
|
$ErrorActionPreference = "Stop"
|
|
Set-StrictMode -Version 3.0
|
|
|
|
# Avoid being run in a "Developer" shell since this script launches its own sub-shells targeting
|
|
# different architectures, and these variables cause confusion.
|
|
if ($env:VSCMD_ARG_HOST_ARCH -or $env:VSCMD_ARG_TGT_ARCH) {
|
|
throw "At least one of VSCMD_ARG_HOST_ARCH and VSCMD_ARG_TGT_ARCH is set, which is incompatible with this script. Likely need to run outside of a Developer shell."
|
|
}
|
|
|
|
# Prevent elsewhere-installed swift modules from confusing our builds.
|
|
$env:SDKROOT = ""
|
|
|
|
$CustomWinSDKRoot = $null # Overwritten if we download a Windows SDK from nuget
|
|
|
|
# Avoid $env:ProgramFiles in case this script is running as x86
|
|
$UnixToolsBinDir = "$env:SystemDrive\Program Files\Git\usr\bin"
|
|
|
|
## Cleanup build arguments.
|
|
|
|
# Validate that if one is set all are set.
|
|
if (($PinnedBuild -or $PinnedSHA256 -or $PinnedVersion) -and -not ($PinnedBuild -and $PinnedSHA256 -and $PinnedVersion)) {
|
|
throw "If any of PinnedBuild, PinnedSHA256, or PinnedVersion is set, all three must be set."
|
|
}
|
|
|
|
if ($Android -and ($AndroidSDKs.Length -eq 0)) {
|
|
# Enable all android SDKs by default.
|
|
$AndroidSDKs = @("aarch64","armv7","i686","x86_64")
|
|
}
|
|
|
|
# Work around limitations of cmd passing in array arguments via powershell.exe -File
|
|
if ($AndroidSDKs.Length -eq 1) { $AndroidSDKs = $AndroidSDKs[0].Split(",") }
|
|
if ($WindowsSDKs.Length -eq 1) { $WindowsSDKs = $WindowsSDKs[0].Split(",") }
|
|
if ($Test.Length -eq 1) { $Test = $Test[0].Split(",") }
|
|
|
|
if ($AndroidSDKs.Length -gt 0) {
|
|
# Always enable android when one of the SDKs is specified.
|
|
$Android = $true
|
|
}
|
|
|
|
if ($Test -contains "*") {
|
|
# Explicitly don't include llbuild yet since tests are known to fail on Windows
|
|
$Test = @("lld", "lldb", "swift", "dispatch", "foundation", "xctest", "swift-format", "sourcekit-lsp")
|
|
}
|
|
|
|
## Declare static build and build tool parameters.
|
|
|
|
$DefaultPinned = @{
|
|
AMD64 = @{
|
|
PinnedBuild = "https://download.swift.org/swift-6.0.3-release/windows10/swift-6.0.3-RELEASE/swift-6.0.3-RELEASE-windows10.exe";
|
|
PinnedSHA256 = "AB205D83A38047882DB80E6A88C7D33B651F3BAC96D4515D7CBA5335F37999D3";
|
|
PinnedVersion = "6.0.3";
|
|
};
|
|
ARM64 = @{
|
|
PinnedBuild = "https://download.swift.org/swift-6.0.3-release/windows10-arm64/swift-6.0.3-RELEASE/swift-6.0.3-RELEASE-windows10-arm64.exe";
|
|
PinnedSHA256 = "81474651E59A9955C9E6A389EF53ABD61631FFC62C63A2A02977271019E7C722";
|
|
PinnedVersion = "6.0.3";
|
|
};
|
|
}
|
|
|
|
enum OS {
|
|
Windows
|
|
Android
|
|
}
|
|
|
|
$KnownPlatforms = @{
|
|
WindowsARM64 = @{
|
|
OS = [OS]::Windows;
|
|
Triple = "aarch64-unknown-windows-msvc";
|
|
Architecture = @{
|
|
VSName = "arm64";
|
|
CMakeName = "ARM64";
|
|
LLVMName = "aarch64";
|
|
ShortName = "arm64";
|
|
};
|
|
BinaryDir = "bin64a";
|
|
Cache = @{};
|
|
};
|
|
|
|
WindowsX64 = @{
|
|
OS = [OS]::Windows;
|
|
Triple = "x86_64-unknown-windows-msvc";
|
|
Architecture = @{
|
|
VSName = "amd64";
|
|
CMakeName = "AMD64";
|
|
LLVMName = "x86_64";
|
|
ShortName = "x64";
|
|
};
|
|
BinaryDir = "bin64";
|
|
Cache = @{};
|
|
};
|
|
|
|
WindowsX86 = @{
|
|
OS = [OS]::Windows;
|
|
Triple = "i686-unknown-windows-msvc";
|
|
Architecture = @{
|
|
VSName = "x86";
|
|
CMakeName = "i686";
|
|
LLVMName = "i686";
|
|
ShortName = "x86";
|
|
};
|
|
BinaryDir = "bin32";
|
|
Cache = @{};
|
|
};
|
|
|
|
AndroidARMv7 = @{
|
|
OS = [OS]::Android;
|
|
Triple = "armv7-unknown-linux-androideabi$AndroidAPILevel";
|
|
Architecture = @{
|
|
ABI = "armeabi-v7a";
|
|
CMakeName = "armv7-a";
|
|
LLVMName = "armv7";
|
|
ShortName = "armv7";
|
|
};
|
|
BinaryDir = "bin32a";
|
|
Cache = @{};
|
|
};
|
|
|
|
AndroidARM64 = @{
|
|
OS = [OS]::Android;
|
|
Triple = "aarch64-unknown-linux-android$AndroidAPILevel";
|
|
Architecture = @{
|
|
ABI = "arm64-v8a";
|
|
CMakeName = "aarch64";
|
|
LLVMName = "aarch64";
|
|
ShortName = "arm64";
|
|
};
|
|
BinaryDir = "bin64a";
|
|
Cache = @{};
|
|
};
|
|
|
|
AndroidX86 = @{
|
|
OS = [OS]::Android;
|
|
Triple = "i686-unknown-linux-android$AndroidAPILevel";
|
|
Architecture = @{
|
|
ABI = "x86";
|
|
CMakeName = "i686";
|
|
LLVMName = "i686";
|
|
ShortName = "x86";
|
|
};
|
|
BinaryDir = "bin32";
|
|
Cache = @{};
|
|
};
|
|
|
|
AndroidX64 = @{
|
|
OS = [OS]::Android;
|
|
Triple = "x86_64-unknown-linux-android$AndroidAPILevel";
|
|
Architecture = @{
|
|
ABI = "x86_64";
|
|
CMakeName = "x86_64";
|
|
LLVMName = "x86_64";
|
|
ShortName = "x64";
|
|
};
|
|
BinaryDir = "bin64";
|
|
Cache = @{};
|
|
};
|
|
}
|
|
|
|
$WiX = @{
|
|
Version = "4.0.6";
|
|
URL = "https://www.nuget.org/api/v2/package/wix/4.0.6";
|
|
SHA256 = "A94DD42AE1FB56B32DA180E2173CEDA4F0D10B4C8871C5EE59ECB502131A1EB6";
|
|
Path = [IO.Path]::Combine("$BinaryCache\WiX-4.0.6", "tools", "net6.0", "any");
|
|
}
|
|
|
|
$KnownPythons = @{
|
|
"3.9.10" = @{
|
|
AMD64 = @{
|
|
URL = "https://www.nuget.org/api/v2/package/python/3.9.10";
|
|
SHA256 = "ac43b491e9488ac926ed31c5594f0c9409a21ecbaf99dc7a93f8c7b24cf85867";
|
|
};
|
|
ARM64 = @{
|
|
URL = "https://www.nuget.org/api/v2/package/pythonarm64/3.9.10";
|
|
SHA256 = "429ada77e7f30e4bd8ff22953a1f35f98b2728e84c9b1d006712561785641f69";
|
|
};
|
|
}
|
|
}
|
|
|
|
$PythonWheels = @{
|
|
"packaging" = @{
|
|
File = "packaging-24.1-py3-none-any.whl";
|
|
URL = "https://files.pythonhosted.org/packages/08/aa/cc0199a5f0ad350994d660967a8efb233fe0416e4639146c089643407ce6/packaging-24.1-py3-none-any.whl";
|
|
SHA256 = "5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124";
|
|
};
|
|
"distutils" = @{
|
|
File = "setuptools-75.1.0-py3-none-any.whl";
|
|
URL = "https://files.pythonhosted.org/packages/ff/ae/f19306b5a221f6a436d8f2238d5b80925004093fa3edea59835b514d9057/setuptools-75.1.0-py3-none-any.whl";
|
|
SHA256 = "35ab7fd3bcd95e6b7fd704e4a1539513edad446c097797f2985e0e4b960772f2";
|
|
};
|
|
"psutil" = @{
|
|
File = "psutil-6.1.0-cp37-abi3-win_amd64.whl";
|
|
URL = "https://files.pythonhosted.org/packages/11/91/87fa6f060e649b1e1a7b19a4f5869709fbf750b7c8c262ee776ec32f3028/psutil-6.1.0-cp37-abi3-win_amd64.whl";
|
|
SHA256 = "a8fb3752b491d246034fa4d279ff076501588ce8cbcdbb62c32fd7a377d996be";
|
|
};
|
|
"unittest2" = @{
|
|
File = "unittest2-1.1.0-py2.py3-none-any.whl";
|
|
URL = "https://files.pythonhosted.org/packages/72/20/7f0f433060a962200b7272b8c12ba90ef5b903e218174301d0abfd523813/unittest2-1.1.0-py2.py3-none-any.whl";
|
|
SHA256 = "13f77d0875db6d9b435e1d4f41e74ad4cc2eb6e1d5c824996092b3430f088bb8";
|
|
};
|
|
}
|
|
|
|
$KnownNDKs = @{
|
|
r26b = @{
|
|
URL = "https://dl.google.com/android/repository/android-ndk-r26b-windows.zip"
|
|
SHA256 = "A478D43D4A45D0D345CDA6BE50D79642B92FB175868D9DC0DFC86181D80F691E"
|
|
ClangVersion = 17
|
|
}
|
|
r27c = @{
|
|
URL = "https://dl.google.com/android/repository/android-ndk-r27c-windows.zip"
|
|
SHA256 = "27E49F11E0CEE5800983D8AF8F4ACD5BF09987AA6F790D4439DDA9F3643D2494"
|
|
ClangVersion = 18
|
|
}
|
|
}
|
|
|
|
$BuildArchName = if ($env:PROCESSOR_ARCHITEW6432) { $env:PROCESSOR_ARCHITEW6432 } else { $env:PROCESSOR_ARCHITECTURE }
|
|
# TODO: Support other cross-compilation scenarios.
|
|
$BuildOS = [OS]::Windows
|
|
$HostOS = [OS]::Windows
|
|
|
|
$vswhere = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe"
|
|
$VSInstallRoot = & $vswhere -nologo -latest -products "*" -all -prerelease -property installationPath
|
|
$msbuild = "$VSInstallRoot\MSBuild\Current\Bin\$BuildArchName\MSBuild.exe"
|
|
|
|
$NugetRoot = "$BinaryCache\nuget"
|
|
$LibraryRoot = "$ImageRoot\Library"
|
|
|
|
## Select and prepare build tools, platforms, parameters, etc.
|
|
|
|
if (-not $PinnedBuild) {
|
|
if (-not $DefaultPinned.ContainsKey($BuildArchName)) {
|
|
throw "Default pinned toolchain definition does not contain an entry for '$BuildArchName'."
|
|
}
|
|
$PinnedBuild = $DefaultPinned[$BuildArchName].PinnedBuild
|
|
$PinnedSHA256 = $DefaultPinned[$BuildArchName].PinnedSHA256
|
|
$PinnedVersion = $DefaultPinned[$BuildArchName].PinnedVersion
|
|
}
|
|
|
|
$PinnedToolchain = [IO.Path]::GetFileNameWithoutExtension($PinnedBuild)
|
|
|
|
$HostPlatform = switch ($HostArchName) {
|
|
"AMD64" { $KnownPlatforms[$HostOS.ToString() + "X64"] }
|
|
"ARM64" { $KnownPlatforms[$HostOS.ToString() + "ARM64"] }
|
|
default { throw "Unsupported processor architecture" }
|
|
}
|
|
|
|
$BuildPlatform = switch ($BuildArchName) {
|
|
"AMD64" { $KnownPlatforms[$BuildOS.ToString() + "X64"] }
|
|
"ARM64" { $KnownPlatforms[$BuildOS.ToString() + "ARM64"] }
|
|
default { throw "Unsupported processor architecture" }
|
|
}
|
|
|
|
$IsCrossCompiling = $HostArchName -ne $BuildArchName
|
|
|
|
if ($Android -and ($HostPlatform -ne $KnownPlatforms["WindowsX64"])) {
|
|
throw "Unsupported host architecture for building android SDKs"
|
|
}
|
|
|
|
# Resolve the architectures received as argument
|
|
$AndroidSDKPlatforms = @($AndroidSDKs | ForEach-Object {
|
|
switch ($_) {
|
|
"aarch64" { $KnownPlatforms["AndroidARM64"] }
|
|
"armv7" { $KnownPlatforms["AndroidARMv7"] }
|
|
"i686" { $KnownPlatforms["AndroidX86"] }
|
|
"x86_64" { $KnownPlatforms["AndroidX64"] }
|
|
default { throw "No Android platform for architecture $_" }
|
|
}
|
|
})
|
|
|
|
$WindowsSDKPlatforms = @($WindowsSDKs | ForEach-Object {
|
|
switch ($_) {
|
|
"X64" { $KnownPlatforms["WindowsX64"] }
|
|
"X86" { $KnownPlatforms["WindowsX86"] }
|
|
"Arm64" { $KnownPlatforms["WindowsArm64"] }
|
|
default { throw "No Windows platform for architecture $_" }
|
|
}
|
|
})
|
|
|
|
## Helpers for logging and timing build steps.
|
|
|
|
$TimingData = New-Object System.Collections.Generic.List[System.Object]
|
|
|
|
function Add-TimingData {
|
|
param
|
|
(
|
|
[Parameter(Mandatory)]
|
|
[Hashtable] $Platform,
|
|
[Parameter(Mandatory)]
|
|
[string] $BuildStep,
|
|
[Parameter(Mandatory)]
|
|
[System.TimeSpan] $ElapsedTime
|
|
)
|
|
|
|
$TimingData.Add([PSCustomObject]@{
|
|
Arch = $Platform.Architecture.LLVMName
|
|
Platform = $Platform.OS.ToString()
|
|
"Build Step" = $BuildStep
|
|
"Elapsed Time" = $ElapsedTime
|
|
})
|
|
}
|
|
|
|
function Write-Summary {
|
|
Write-Host "Summary:" -ForegroundColor Cyan
|
|
|
|
$TotalTime = [TimeSpan]::Zero
|
|
foreach ($Entry in $TimingData) {
|
|
$TotalTime = $TotalTime.Add($Entry."Elapsed Time")
|
|
}
|
|
|
|
$SortedData = $TimingData | ForEach-Object {
|
|
$Percentage = [math]::Round(($_.("Elapsed Time").TotalSeconds / $TotalTime.TotalSeconds) * 100, 1)
|
|
$FormattedTime = "{0:hh\:mm\:ss\.ff}" -f $_."Elapsed Time"
|
|
[PSCustomObject]@{
|
|
"Build Step" = $_."Build Step"
|
|
Platform = $_.Platform
|
|
Arch = $_.Arch
|
|
"Elapsed Time" = $FormattedTime
|
|
"%" = "$Percentage%"
|
|
}
|
|
} | Sort-Object -Descending -Property "Elapsed Time"
|
|
|
|
$FormattedTotalTime = "{0:hh\:mm\:ss\.ff}" -f $TotalTime
|
|
$TotalRow = [PSCustomObject]@{
|
|
"Build Step" = "TOTAL"
|
|
Platform = ""
|
|
Arch = ""
|
|
"Elapsed Time" = $FormattedTotalTime
|
|
"%" = "100.0%"
|
|
}
|
|
|
|
@($SortedData) + $TotalRow | Format-Table -AutoSize
|
|
}
|
|
|
|
function Get-AndroidNDK {
|
|
$NDK = $KnownNDKs[$AndroidNDKVersion]
|
|
if (-not $NDK) { throw "Unsupported Android NDK version" }
|
|
return $NDK
|
|
}
|
|
|
|
function Get-AndroidNDKPath {
|
|
return Join-Path -Path $BinaryCache -ChildPath "android-ndk-$AndroidNDKVersion"
|
|
}
|
|
|
|
function Get-FlexExecutable {
|
|
return Join-Path -Path $BinaryCache -ChildPath "win_flex_bison\win_flex.exe"
|
|
}
|
|
|
|
function Get-BisonExecutable {
|
|
return Join-Path -Path $BinaryCache -ChildPath "win_flex_bison\win_bison.exe"
|
|
}
|
|
|
|
function Get-PythonPath([Hashtable] $Platform) {
|
|
return [IO.Path]::Combine("$BinaryCache\", "Python$($Platform.Architecture.CMakeName)-$PythonVersion")
|
|
}
|
|
|
|
function Get-PythonExecutable {
|
|
return [IO.Path]::Combine((Get-PythonPath $BuildPlatform), "tools", "python.exe")
|
|
}
|
|
|
|
function Get-PythonScriptsPath {
|
|
return [IO.Path]::Combine((Get-PythonPath $BuildPlatform), "tools", "Scripts")
|
|
}
|
|
|
|
function Get-InstallDir([Hashtable] $Platform) {
|
|
if ($Platform -eq $HostPlatform) {
|
|
$ProgramFilesName = "Program Files"
|
|
} elseif ($Platform -eq $KnownPlatforms["WindowsX86"]) {
|
|
$ProgramFilesName = "Program Files (x86)"
|
|
} elseif (($HostPlatform -eq $KnownPlatforms["WindowsARM64"]) -and ($Platform -eq $KnownPlatforms["WindowsX64"])) {
|
|
# x64 programs actually install under "Program Files" on arm64,
|
|
# but this would conflict with the native installation.
|
|
$ProgramFilesName = "Program Files (Amd64)"
|
|
} else {
|
|
# arm64 cannot be installed on x64
|
|
return $null
|
|
}
|
|
return "$ImageRoot\$ProgramFilesName\Swift"
|
|
}
|
|
|
|
# For dev productivity, install the host toolchain directly using CMake.
|
|
# This allows iterating on the toolchain using ninja builds.
|
|
$HostPlatform.ToolchainInstallRoot = "$(Get-InstallDir $HostPlatform)\Toolchains\$ProductVersion+$Variant"
|
|
$BuildPlatform.ToolchainInstallRoot = "$(Get-InstallDir $BuildPlatform)\Toolchains\$ProductVersion+$Variant"
|
|
|
|
# Build functions
|
|
function Invoke-BuildStep {
|
|
[CmdletBinding(PositionalBinding = $false)]
|
|
param
|
|
(
|
|
[Parameter(Position=0, Mandatory)]
|
|
[string] $Name,
|
|
[Parameter(Position=1, Mandatory)]
|
|
[Hashtable] $Platform,
|
|
[Parameter(ValueFromRemainingArguments)]
|
|
$RemainingArgs
|
|
)
|
|
|
|
if ($Summary) {
|
|
$Stopwatch = [Diagnostics.Stopwatch]::StartNew()
|
|
}
|
|
|
|
$SplatArgs = @{}
|
|
foreach ($Arg in $RemainingArgs) {
|
|
if ($Arg -is [Hashtable]) {
|
|
$SplatArgs += $Arg
|
|
} elseif ($Arg -is [string]) {
|
|
$SplatArgs[$Arg.TrimStart('-')] = $true
|
|
} else {
|
|
throw "$Arg is unknown type: $($Arg.GetType())"
|
|
}
|
|
}
|
|
|
|
& $Name $Platform @SplatArgs
|
|
|
|
if ($Summary) {
|
|
Add-TimingData $Platform $Name $Stopwatch.Elapsed
|
|
}
|
|
if ($Name.Replace("Build-", "") -eq $BuildTo) {
|
|
exit 0
|
|
}
|
|
}
|
|
|
|
enum Project {
|
|
BuildTools
|
|
RegsGen2
|
|
|
|
Compilers
|
|
FoundationMacros
|
|
TestingMacros
|
|
ToolsSupportCore
|
|
LLBuild
|
|
ArgumentParser
|
|
Driver
|
|
Crypto
|
|
Collections
|
|
ASN1
|
|
Certificates
|
|
System
|
|
Build
|
|
PackageManager
|
|
Markdown
|
|
Format
|
|
LMDB
|
|
IndexStoreDB
|
|
SourceKitLSP
|
|
SymbolKit
|
|
DocC
|
|
|
|
LLVM
|
|
Runtime
|
|
Dispatch
|
|
DynamicFoundation
|
|
XCTest
|
|
Testing
|
|
ClangBuiltins
|
|
ClangRuntime
|
|
SwiftInspect
|
|
ExperimentalRuntime
|
|
StaticFoundation
|
|
}
|
|
|
|
function Get-ProjectBinaryCache([Hashtable] $Platform, [Project] $Project) {
|
|
if ($Project -eq [Project]::Compilers) {
|
|
if ($Platform -eq $HostPlatform) { return "$BinaryCache\5" }
|
|
if ($Platform -eq $BuildPlatform) { return "$BinaryCache\1" }
|
|
throw "Building Compilers for $($Platform.Triple) currently unsupported."
|
|
}
|
|
return "$([IO.Path]::Combine("$BinaryCache\", $Platform.Triple, $Project.ToString()))"
|
|
}
|
|
|
|
function Get-ProjectCMakeModules {
|
|
[CmdletBinding(PositionalBinding = $false)]
|
|
param
|
|
(
|
|
[Parameter(Position = 0, Mandatory = $true)]
|
|
[Hashtable] $Platform,
|
|
[Parameter(Position = 1, Mandatory = $true)]
|
|
[Project] $Project
|
|
)
|
|
|
|
return "$([IO.Path]::Combine((Get-ProjectBinaryCache $Platform $Project), "cmake", "modules"))"
|
|
}
|
|
|
|
function Get-TargetInfo([Hashtable] $Platform) {
|
|
# Cache the result of "swiftc -print-target-info" as $Platform.Cache.TargetInfo
|
|
$CacheKey = "TargetInfo"
|
|
if (-not $Platform.Cache.ContainsKey($CacheKey)) {
|
|
Invoke-IsolatingEnvVars {
|
|
$env:Path = "$(Get-PinnedToolchainRuntime);$(Get-PinnedToolchainToolsDir);${env:Path}"
|
|
$TargetInfo = & swiftc -target $Platform.Triple -print-target-info
|
|
if ($LastExitCode -ne 0) {
|
|
throw "Unable to print target info for '$($Platform.Triple)'"
|
|
}
|
|
$TargetInfo = $TargetInfo | ConvertFrom-JSON
|
|
$Platform.Cache[$CacheKey] = $TargetInfo.target
|
|
}
|
|
}
|
|
return $Platform.Cache[$CacheKey]
|
|
}
|
|
|
|
function Get-ModuleTriple([Hashtable] $Platform) {
|
|
return (Get-TargetInfo $Platform).moduleTriple
|
|
}
|
|
|
|
function Copy-File($Src, $Dst) {
|
|
# Create the directory tree first so Copy-Item succeeds
|
|
# If $Dst is the target directory, make sure it ends with "\"
|
|
$DstDir = [IO.Path]::GetDirectoryName($Dst)
|
|
if ($ToBatch) {
|
|
Write-Output "md `"$DstDir`""
|
|
Write-Output "copy /Y `"$Src`" `"$Dst`""
|
|
} else {
|
|
New-Item -ItemType Directory -ErrorAction Ignore $DstDir | Out-Null
|
|
Copy-Item -Force $Src $Dst
|
|
}
|
|
}
|
|
|
|
function Copy-Directory($Src, $Dst) {
|
|
if ($ToBatch) {
|
|
Write-Output "md `"$Dst`""
|
|
Write-Output "copy /Y `"$Src`" `"$Dst`""
|
|
} else {
|
|
New-Item -ItemType Directory -ErrorAction Ignore $Dst | Out-Null
|
|
Copy-Item -Force -Recurse $Src $Dst
|
|
}
|
|
}
|
|
|
|
function Move-Directory($Src, $Dst) {
|
|
if ($ToBatch) {
|
|
} else {
|
|
$Destination = Join-Path -Path $Dst -ChildPath (Split-Path -Path $Src -Leaf)
|
|
if (Test-Path -Path $Destination -Type Container) {
|
|
Remove-Item -Path $Destination -Recurse -Force | Out-Null
|
|
}
|
|
Move-Item -Path $Src -Destination $Dst -Force | Out-Null
|
|
}
|
|
}
|
|
|
|
function Invoke-Program() {
|
|
[CmdletBinding(PositionalBinding = $false)]
|
|
param
|
|
(
|
|
[Parameter(Position = 0, Mandatory = $true)]
|
|
[string] $Executable,
|
|
[switch] $Silent,
|
|
[switch] $OutNull,
|
|
[string] $OutFile = "",
|
|
[string] $ErrorFile = "",
|
|
[Parameter(Position = 1, ValueFromRemainingArguments)]
|
|
[string[]] $ExecutableArgs
|
|
)
|
|
|
|
if ($ToBatch) {
|
|
# Print the invocation in batch file-compatible format
|
|
$OutputLine = "`"$Executable`""
|
|
$ShouldBreakLine = $false
|
|
for ($i = 0; $i -lt $ExecutableArgs.Length; $i++) {
|
|
if ($ShouldBreakLine -or $OutputLine.Length -ge 40) {
|
|
$OutputLine += " ^"
|
|
Write-Output $OutputLine
|
|
$OutputLine = " "
|
|
}
|
|
|
|
$Arg = $ExecutableArgs[$i]
|
|
if ($Arg.Contains(" ")) {
|
|
$OutputLine += " `"$Arg`""
|
|
} else {
|
|
$OutputLine += " $Arg"
|
|
}
|
|
|
|
# Break lines after non-switch arguments
|
|
$ShouldBreakLine = -not $Arg.StartsWith("-")
|
|
}
|
|
|
|
if ($OutNull) {
|
|
$OutputLine += " > nul"
|
|
} elseif ($Silent) {
|
|
$OutputLine += " *> nul"
|
|
} else {
|
|
if ($OutFile) { $OutputLine += " > `"$OutFile`"" }
|
|
if ($ErrorFile) { $OutputLine += " 2> `"$ErrorFile`"" }
|
|
}
|
|
|
|
Write-Output $OutputLine
|
|
} else {
|
|
if ($OutNull) {
|
|
& $Executable @ExecutableArgs | Out-Null
|
|
} elseif ($Silent) {
|
|
& $Executable @ExecutableArgs *> $null
|
|
} elseif ($OutFile -and $ErrorFile) {
|
|
& $Executable @ExecutableArgs > $OutFile 2> $ErrorFile
|
|
} elseif ($OutFile) {
|
|
& $Executable @ExecutableArgs > $OutFile
|
|
} elseif ($ErrorFile) {
|
|
& $Executable @ExecutableArgs 2> $ErrorFile
|
|
} else {
|
|
& $Executable @ExecutableArgs
|
|
}
|
|
|
|
if ($LastExitCode -ne 0) {
|
|
$ErrorMessage = "Error: $([IO.Path]::GetFileName($Executable)) exited with code $($LastExitCode).`n"
|
|
|
|
$ErrorMessage += "Invocation:`n"
|
|
$ErrorMessage += " $Executable $ExecutableArgs`n"
|
|
|
|
$ErrorMessage += "Call stack:`n"
|
|
foreach ($Frame in @(Get-PSCallStack)) {
|
|
$ErrorMessage += " $Frame`n"
|
|
}
|
|
|
|
throw $ErrorMessage
|
|
}
|
|
}
|
|
}
|
|
|
|
function Invoke-IsolatingEnvVars([scriptblock]$Block) {
|
|
if ($ToBatch) {
|
|
Write-Output "setlocal enableextensions enabledelayedexpansion"
|
|
}
|
|
|
|
$OldVars = @{}
|
|
foreach ($Var in (Get-ChildItem env:*).GetEnumerator()) {
|
|
$OldVars.Add($Var.Key, $Var.Value)
|
|
}
|
|
|
|
& $Block
|
|
|
|
Remove-Item env:*
|
|
foreach ($Var in $OldVars.GetEnumerator()) {
|
|
New-Item -Path "env:\$($Var.Key)" -Value $Var.Value -ErrorAction Ignore | Out-Null
|
|
}
|
|
|
|
if ($ToBatch) {
|
|
Write-Output "endlocal"
|
|
}
|
|
}
|
|
|
|
function Invoke-VsDevShell([Hashtable] $Platform) {
|
|
if (($Platform.OS -ne [OS]::Windows) -or ($BuildPlatform.OS -ne [OS]::Windows)) {
|
|
Write-Warning "Invoke-VsDevShell called on non-Windows platform."
|
|
return
|
|
}
|
|
|
|
$DevCmdArguments = "-no_logo -host_arch=$($BuildPlatform.Architecture.VSName) -arch=$($Platform.Architecture.VSName)"
|
|
if ($CustomWinSDKRoot) {
|
|
$DevCmdArguments += " -winsdk=none"
|
|
} elseif ($WinSDKVersion) {
|
|
$DevCmdArguments += " -winsdk=$WinSDKVersion"
|
|
}
|
|
|
|
if ($ToBatch) {
|
|
Write-Output "call `"$VSInstallRoot\Common7\Tools\VsDevCmd.bat`" $DevCmdArguments"
|
|
} else {
|
|
# This dll path is valid for VS2019 and VS2022, but it was under a vsdevcmd subfolder in VS2017
|
|
Import-Module "$VSInstallRoot\Common7\Tools\Microsoft.VisualStudio.DevShell.dll"
|
|
Enter-VsDevShell -VsInstallPath $VSInstallRoot -SkipAutomaticLocation -DevCmdArguments $DevCmdArguments
|
|
|
|
if ($CustomWinSDKRoot) {
|
|
# Using a non-installed Windows SDK. Setup environment variables manually.
|
|
$WinSDKVerIncludeRoot = "$CustomWinSDKRoot\include\$WinSDKVersion"
|
|
$WinSDKIncludePath = "$WinSDKVerIncludeRoot\ucrt;$WinSDKVerIncludeRoot\um;$WinSDKVerIncludeRoot\shared;$WinSDKVerIncludeRoot\winrt;$WinSDKVerIncludeRoot\cppwinrt"
|
|
$WinSDKVerLibRoot = "$CustomWinSDKRoot\lib\$WinSDKVersion"
|
|
|
|
$env:WindowsLibPath = "$CustomWinSDKRoot\UnionMetadata\$WinSDKVersion;$CustomWinSDKRoot\References\$WinSDKVersion"
|
|
$env:WindowsSdkBinPath = "$CustomWinSDKRoot\bin"
|
|
$env:WindowsSDKLibVersion = "$WinSDKVersion\"
|
|
$env:WindowsSdkVerBinPath = "$CustomWinSDKRoot\bin\$WinSDKVersion"
|
|
$env:WindowsSDKVersion = "$WinSDKVersion\"
|
|
|
|
$env:EXTERNAL_INCLUDE += ";$WinSDKIncludePath"
|
|
$env:INCLUDE += ";$WinSDKIncludePath"
|
|
$env:LIB += ";$WinSDKVerLibRoot\ucrt\$($Platform.Architecture.ShortName);$WinSDKVerLibRoot\um\$($Platform.Architecture.ShortName)"
|
|
$env:LIBPATH += ";$env:WindowsLibPath"
|
|
$env:PATH += ";$env:WindowsSdkVerBinPath\$($Platform.Architecture.ShortName);$env:WindowsSdkBinPath\$($Platform.Architecture.ShortName)"
|
|
$env:UCRTVersion = $WinSDKVersion
|
|
$env:UniversalCRTSdkDir = $CustomWinSDKRoot
|
|
}
|
|
}
|
|
}
|
|
|
|
function Get-Dependencies {
|
|
Write-Host "[$([DateTime]::Now.ToString("yyyy-MM-dd HH:mm:ss"))] Fetch-Dependencies ..." -ForegroundColor Cyan
|
|
$ProgressPreference = "SilentlyContinue"
|
|
|
|
$WebClient = New-Object Net.WebClient
|
|
|
|
function DownloadAndVerify($URL, $Destination, $Hash) {
|
|
if (Test-Path $Destination) {
|
|
return
|
|
}
|
|
|
|
Write-Output "$Destination not found. Downloading ..."
|
|
if ($ToBatch) {
|
|
Write-Output "md `"$(Split-Path -Path $Destination -Parent)`""
|
|
Write-Output "curl.exe -sL $URL -o $Destination"
|
|
Write-Output "(certutil -HashFile $Destination SHA256) == $Hash || (exit /b)"
|
|
} else {
|
|
New-Item -ItemType Directory (Split-Path -Path $Destination -Parent) -ErrorAction Ignore | Out-Null
|
|
$WebClient.DownloadFile($URL, $Destination)
|
|
$SHA256 = Get-FileHash -Path $Destination -Algorithm SHA256
|
|
if ($SHA256.Hash -ne $Hash) {
|
|
throw "SHA256 mismatch ($($SHA256.Hash) vs $Hash)"
|
|
}
|
|
}
|
|
}
|
|
|
|
function Expand-ZipFile {
|
|
param
|
|
(
|
|
[string]$ZipFileName,
|
|
[string]$BinaryCache,
|
|
[string]$ExtractPath,
|
|
[bool]$CreateExtractPath = $true
|
|
)
|
|
|
|
$source = Join-Path -Path $BinaryCache -ChildPath $ZipFileName
|
|
$destination = Join-Path -Path $BinaryCache -ChildPath $ExtractPath
|
|
|
|
# Check if the extracted directory already exists and is up to date.
|
|
if (Test-Path $destination) {
|
|
$zipLastWriteTime = (Get-Item $source).LastWriteTime
|
|
$extractedLastWriteTime = (Get-Item $destination).LastWriteTime
|
|
# Compare the last write times
|
|
if ($zipLastWriteTime -le $extractedLastWriteTime) {
|
|
Write-Output "'$ZipFileName' is already extracted and up to date."
|
|
return
|
|
}
|
|
}
|
|
|
|
$destination = if ($CreateExtractPath) { $destination } else { $BinaryCache }
|
|
|
|
Write-Output "Extracting '$ZipFileName' ..."
|
|
New-Item -ItemType Directory -ErrorAction Ignore -Path $BinaryCache | Out-Null
|
|
Expand-Archive -Path $source -DestinationPath $destination -Force
|
|
}
|
|
|
|
function Export-Toolchain {
|
|
param
|
|
(
|
|
[string]$InstallerExeName,
|
|
[string]$BinaryCache,
|
|
[string]$ToolchainName
|
|
)
|
|
|
|
$source = Join-Path -Path $BinaryCache -ChildPath $InstallerExeName
|
|
$destination = Join-Path -Path $BinaryCache -ChildPath toolchains\$ToolchainName
|
|
|
|
# Check if the extracted directory already exists and is up to date.
|
|
if (Test-Path $destination) {
|
|
$installerWriteTime = (Get-Item $source).LastWriteTime
|
|
$extractedWriteTime = (Get-Item $destination).LastWriteTime
|
|
if ($installerWriteTime -le $extractedWriteTime) {
|
|
Write-Output "'$InstallerExeName' is already extracted and up to date."
|
|
return
|
|
}
|
|
}
|
|
|
|
Write-Output "Extracting '$InstallerExeName' ..."
|
|
|
|
# The new runtime MSI is built to expand files into the immediate directory. So, setup the installation location.
|
|
New-Item -ItemType Directory -ErrorAction Ignore $BinaryCache\toolchains\$PinnedToolchain\LocalApp\Programs\Swift\Runtimes\$(Get-PinnedToolchainVersion)\usr\bin | Out-Null
|
|
Invoke-Program "$($WiX.Path)\wix.exe" -- burn extract $BinaryCache\$InstallerExeName -out $BinaryCache\toolchains\ -outba $BinaryCache\toolchains\
|
|
Get-ChildItem "$BinaryCache\toolchains\WixAttachedContainer" -Filter "*.msi" | ForEach-Object {
|
|
$LogFile = [System.IO.Path]::ChangeExtension($_.Name, "log")
|
|
$TARGETDIR = if ($_.Name -eq "rtl.msi") { "$BinaryCache\toolchains\$ToolchainName\LocalApp\Programs\Swift\Runtimes\$(Get-PinnedToolchainVersion)\usr\bin" } else { "$BinaryCache\toolchains\$ToolchainName" }
|
|
Invoke-Program -OutNull msiexec.exe /lvx! $BinaryCache\toolchains\$LogFile /qn /a $BinaryCache\toolchains\WixAttachedContainer\$($_.Name) ALLUSERS=0 TARGETDIR=$TARGETDIR
|
|
}
|
|
}
|
|
|
|
if ($SkipBuild -and $SkipPackaging) { return }
|
|
|
|
$Stopwatch = [Diagnostics.Stopwatch]::StartNew()
|
|
if ($ToBatch) {
|
|
Write-Host -ForegroundColor Cyan "[$([DateTime]::Now.ToString("yyyy-MM-dd HH:mm:ss"))] Get-Dependencies..."
|
|
}
|
|
|
|
DownloadAndVerify $WiX.URL "$BinaryCache\WiX-$($WiX.Version).zip" $WiX.SHA256
|
|
Expand-ZipFile WiX-$($WiX.Version).zip $BinaryCache WiX-$($WiX.Version)
|
|
|
|
if ($SkipBuild) { return }
|
|
|
|
DownloadAndVerify $PinnedBuild "$BinaryCache\$PinnedToolchain.exe" $PinnedSHA256
|
|
|
|
if ($Test -contains "lldb") {
|
|
# The make tool isn't part of MSYS
|
|
$GnuWin32MakeURL = "https://downloads.sourceforge.net/project/ezwinports/make-4.4.1-without-guile-w32-bin.zip"
|
|
$GnuWin32MakeHash = "fb66a02b530f7466f6222ce53c0b602c5288e601547a034e4156a512dd895ee7"
|
|
DownloadAndVerify $GnuWin32MakeURL "$BinaryCache\GnuWin32Make-4.4.1.zip" $GnuWin32MakeHash
|
|
Expand-ZipFile GnuWin32Make-4.4.1.zip $BinaryCache GnuWin32Make-4.4.1
|
|
}
|
|
|
|
# TODO(compnerd) stamp/validate that we need to re-extract
|
|
New-Item -ItemType Directory -ErrorAction Ignore $BinaryCache\toolchains | Out-Null
|
|
Export-Toolchain "$PinnedToolchain.exe" $BinaryCache $PinnedToolchain
|
|
|
|
function Get-KnownPython([string] $ArchName) {
|
|
if (-not $KnownPythons.ContainsKey($PythonVersion)) {
|
|
throw "Unknown python version: $PythonVersion"
|
|
}
|
|
return $KnownPythons[$PythonVersion].$ArchName
|
|
}
|
|
|
|
function Install-Python([string] $ArchName) {
|
|
$Python = Get-KnownPython $ArchName
|
|
DownloadAndVerify $Python.URL "$BinaryCache\Python$ArchName-$PythonVersion.zip" $Python.SHA256
|
|
if (-not $ToBatch) {
|
|
Expand-ZipFile Python$ArchName-$PythonVersion.zip "$BinaryCache" Python$ArchName-$PythonVersion
|
|
}
|
|
}
|
|
|
|
function Install-PIPIfNeeded() {
|
|
try {
|
|
Invoke-Program -Silent "$(Get-PythonExecutable)" -m pip
|
|
} catch {
|
|
Write-Output "Installing pip ..."
|
|
Invoke-Program -OutNull "$(Get-PythonExecutable)" '-I' -m ensurepip -U --default-pip
|
|
} finally {
|
|
Write-Output "pip installed."
|
|
}
|
|
}
|
|
|
|
function Install-PythonWheel([string] $ModuleName) {
|
|
try {
|
|
Invoke-Program -Silent "$(Get-PythonExecutable)" -c "import $ModuleName"
|
|
} catch {
|
|
$Wheel = $PythonWheels[$ModuleName]
|
|
DownloadAndVerify $Wheel.URL "$BinaryCache\python\$($Wheel.File)" $Wheel.SHA256
|
|
Write-Output "Installing '$($Wheel.File)' ..."
|
|
Invoke-Program -OutNull "$(Get-PythonExecutable)" '-I' -m pip install "$BinaryCache\python\$($Wheel.File)" --disable-pip-version-check
|
|
} finally {
|
|
Write-Output "$ModuleName installed."
|
|
}
|
|
}
|
|
|
|
function Install-PythonModules() {
|
|
Install-PIPIfNeeded
|
|
Install-PythonWheel "packaging" # For building LLVM 18+
|
|
Install-PythonWheel "distutils" # Required for SWIG support
|
|
if ($Test -contains "lldb") {
|
|
Install-PythonWheel "psutil" # Required for testing LLDB
|
|
$env:Path = "$(Get-PythonScriptsPath);$env:Path" # For unit.exe
|
|
Install-PythonWheel "unittest2" # Required for testing LLDB
|
|
}
|
|
}
|
|
|
|
Install-Python $HostArchName
|
|
if ($IsCrossCompiling) {
|
|
Install-Python $BuildArchName
|
|
}
|
|
|
|
# Ensure Python modules that are required as host build tools
|
|
Install-PythonModules
|
|
|
|
if ($Android) {
|
|
$NDK = Get-AndroidNDK
|
|
DownloadAndVerify $NDK.URL "$BinaryCache\android-ndk-$AndroidNDKVersion-windows.zip" $NDK.SHA256
|
|
Expand-ZipFile -ZipFileName "android-ndk-$AndroidNDKVersion-windows.zip" -BinaryCache $BinaryCache -ExtractPath "android-ndk-$AndroidNDKVersion" -CreateExtractPath $false
|
|
}
|
|
|
|
if ($IncludeDS2) {
|
|
$WinFlexBisonVersion = "2.5.25"
|
|
$WinFlexBisonURL = "https://github.com/lexxmark/winflexbison/releases/download/v$WinFlexBisonVersion/win_flex_bison-$WinFlexBisonVersion.zip"
|
|
$WinFlexBisonHash = "8D324B62BE33604B2C45AD1DD34AB93D722534448F55A16CA7292DE32B6AC135"
|
|
DownloadAndVerify $WinFlexBisonURL "$BinaryCache\win_flex_bison-$WinFlexBisonVersion.zip" $WinFlexBisonHash
|
|
|
|
Expand-ZipFile -ZipFileName "win_flex_bison-$WinFlexBisonVersion.zip" -BinaryCache $BinaryCache -ExtractPath "win_flex_bison"
|
|
}
|
|
|
|
if ($WinSDKVersion) {
|
|
try {
|
|
# Check whether VsDevShell can already resolve the requested Windows SDK Version
|
|
Invoke-IsolatingEnvVars { Invoke-VsDevShell $HostPlatform }
|
|
} catch {
|
|
$Package = Microsoft.Windows.SDK.CPP
|
|
|
|
Write-Output "Windows SDK $WinSDKVersion not found. Downloading from nuget.org ..."
|
|
Invoke-Program nuget install $Package -Version $WinSDKVersion -OutputDirectory $NugetRoot
|
|
|
|
# Set to script scope so Invoke-VsDevShell can read it.
|
|
$script:CustomWinSDKRoot = "$NugetRoot\$Package.$WinSDKVersion\c"
|
|
|
|
# Install each required architecture package and move files under the base /lib directory.
|
|
$WinSDKPlatforms = $WindowsSDKPlatforms.Clone()
|
|
if (-not ($HostPlatform -in $WinSDKPlatforms)) {
|
|
$WinSDKPlatforms += $HostPlatform
|
|
}
|
|
|
|
foreach ($Platform in $WinSDKPlatforms) {
|
|
Invoke-Program nuget install $Package.$($Platform.Architecture.ShortName) -Version $WinSDKVersion -OutputDirectory $NugetRoot
|
|
Copy-Directory "$NugetRoot\$Package.$($Platform.Architecture.ShortName).$WinSDKVersion\c\*" "$CustomWinSDKRoot\lib\$WinSDKVersion"
|
|
}
|
|
}
|
|
}
|
|
|
|
if (-not $ToBatch) {
|
|
Write-Host -ForegroundColor Cyan "[$([DateTime]::Now.ToString("yyyy-MM-dd HH:mm:ss"))] Get-Dependencies took $($Stopwatch.Elapsed)"
|
|
Write-Host ""
|
|
}
|
|
if ($Summary) {
|
|
Add-TimingData $BuildPlatform "Get-Dependencies" $Stopwatch.Elapsed
|
|
}
|
|
}
|
|
|
|
function Get-PinnedToolchainToolsDir() {
|
|
$ToolchainsRoot = [IO.Path]::Combine("$BinaryCache\toolchains", "$PinnedToolchain", "LocalApp", "Programs", "Swift", "Toolchains")
|
|
|
|
# NOTE: Add a workaround for the main snapshots that inadvertently used the
|
|
# wrong version when they were built. This allows use of the nightly snapshot
|
|
# as a pinned toolchain.
|
|
if ((Get-PinnedToolchainVersion) -eq "0.0.0") {
|
|
if (-not (Test-Path "$ToolchainsRoot\0.0.0+Asserts\usr\bin")) {
|
|
if (Test-Path "$ToolchainsRoot\6.0.0+Asserts\usr\bin") {
|
|
return "$ToolchainsRoot\6.0.0+Asserts\usr\bin"
|
|
}
|
|
}
|
|
}
|
|
|
|
$VariantToolchainPath = [IO.Path]::Combine($ToolchainsRoot, "$(Get-PinnedToolchainVersion)+$PinnedToolchainVariant", "usr", "bin")
|
|
|
|
if (Test-Path $VariantToolchainPath) {
|
|
return $VariantToolchainPath
|
|
}
|
|
|
|
return [IO.Path]::Combine("$BinaryCache\", "toolchains", $PinnedToolchain,
|
|
"Library", "Developer", "Toolchains",
|
|
"unknown-$PinnedToolchainVariant-development.xctoolchain", "usr", "bin")
|
|
}
|
|
|
|
function Get-PinnedToolchainSDK() {
|
|
return [IO.Path]::Combine("$BinaryCache\", "toolchains", $PinnedToolchain,
|
|
"LocalApp", "Programs", "Swift", "Platforms", (Get-PinnedToolchainVersion),
|
|
"Windows.platform", "Developer", "SDKs", "Windows.sdk")
|
|
}
|
|
|
|
function Get-PinnedToolchainRuntime() {
|
|
return [IO.Path]::Combine("$BinaryCache\", "toolchains", $PinnedToolchain,
|
|
"LocalApp", "Programs", "Swift", "Runtimes", (Get-PinnedToolchainVersion),
|
|
"usr", "bin")
|
|
}
|
|
|
|
function Get-PinnedToolchainVersion() {
|
|
if (Test-Path variable:PinnedVersion) {
|
|
return $PinnedVersion
|
|
}
|
|
throw "PinnedVersion must be set"
|
|
}
|
|
|
|
function Add-KeyValueIfNew([hashtable]$Hashtable, [string]$Key, [string]$Value) {
|
|
if (-not $Hashtable.Contains($Key)) {
|
|
$Hashtable.Add($Key, $Value)
|
|
}
|
|
}
|
|
|
|
function Add-FlagsDefine([hashtable]$Defines, [string]$Name, [string[]]$Value) {
|
|
if ($Defines.Contains($Name)) {
|
|
$Defines[$name] = @($Defines[$name]) + $Value
|
|
} else {
|
|
$Defines.Add($Name, $Value)
|
|
}
|
|
}
|
|
|
|
function Test-SCCacheAtLeast([int]$Major, [int]$Minor, [int]$Patch = 0) {
|
|
if ($ToBatch) { return $false }
|
|
|
|
$SCCacheVersionString = @(& sccache.exe --version)[0]
|
|
if (-not ($SCCacheVersionString -match "sccache (\d+)\.(\d+)(?:\.(\d+))?")) {
|
|
throw "Unexpected SCCache version string format"
|
|
}
|
|
|
|
if ([int]$Matches.1 -ne $Major) { return [int]$Matches.1 -gt $Major }
|
|
if ([int]$Matches.2 -ne $Minor) { return [int]$Matches.2 -gt $Minor }
|
|
if ($null -eq $Matches.3) { return 0 -gt $Patch }
|
|
return [int]$Matches.3 -ge $Patch
|
|
}
|
|
|
|
function Get-PlatformRoot([OS] $OS) {
|
|
return ([IO.Path]::Combine((Get-InstallDir $HostPlatform), "Platforms", "$($OS.ToString()).platform"))
|
|
}
|
|
|
|
function Get-SwiftSDK {
|
|
param
|
|
(
|
|
[Parameter(Mandatory)]
|
|
[OS] $OS,
|
|
[string] $Identifier = $OS.ToString()
|
|
)
|
|
return ([IO.Path]::Combine((Get-PlatformRoot $OS), "Developer", "SDKs", "$Identifier.sdk"))
|
|
}
|
|
|
|
function Build-CMakeProject {
|
|
[CmdletBinding(PositionalBinding = $false)]
|
|
param
|
|
(
|
|
[string] $Src,
|
|
[string] $Bin,
|
|
[string] $InstallTo = "",
|
|
[hashtable] $Platform,
|
|
[string] $Generator = "Ninja",
|
|
[string] $CacheScript = "",
|
|
[ValidateSet("C", "CXX")]
|
|
[string[]] $UseMSVCCompilers = @(),
|
|
[ValidateSet("ASM", "C", "CXX", "Swift")]
|
|
[string[]] $UseBuiltCompilers = @(),
|
|
[ValidateSet("ASM", "C", "CXX", "Swift")]
|
|
[string[]] $UsePinnedCompilers = @(),
|
|
[switch] $AddAndroidCMakeEnv = $false,
|
|
[switch] $UseGNUDriver = $false,
|
|
[string] $SwiftSDK = "",
|
|
[hashtable] $Defines = @{}, # Values are either single strings or arrays of flags
|
|
[string[]] $BuildTargets = @()
|
|
)
|
|
|
|
if ($ToBatch) {
|
|
Write-Output ""
|
|
Write-Output "echo Building '$Src' to '$Bin' ..."
|
|
} else {
|
|
Write-Host -ForegroundColor Cyan "[$([DateTime]::Now.ToString("yyyy-MM-dd HH:mm:ss"))] Building '$Src' to '$Bin' ..."
|
|
}
|
|
|
|
$Stopwatch = [Diagnostics.Stopwatch]::StartNew()
|
|
|
|
# Enter the developer command shell early so we can resolve cmake.exe
|
|
# for version checks.
|
|
Invoke-IsolatingEnvVars {
|
|
if ($Platform.OS -eq [OS]::Windows) {
|
|
Invoke-VsDevShell $Platform
|
|
}
|
|
|
|
# Add additional defines (unless already present)
|
|
$Defines = $Defines.Clone()
|
|
|
|
if (($Platform.OS -ne [OS]::Windows) -or ($Platform.Architecture.CMakeName -ne $BuildPlatform.Architecture.CMakeName)) {
|
|
Add-KeyValueIfNew $Defines CMAKE_SYSTEM_NAME $Platform.OS.ToString()
|
|
Add-KeyValueIfNew $Defines CMAKE_SYSTEM_PROCESSOR $Platform.Architecture.CMakeName
|
|
}
|
|
|
|
if ($AddAndroidCMakeEnv) {
|
|
# Set generic android options if we need to build an Android runtime component
|
|
# while building the compiler. Use an environment variable to pass it, to
|
|
# ensure that it can be accessed from the cmake cache file.
|
|
$env:NDKPATH = Get-AndroidNDKPath
|
|
}
|
|
|
|
if ($Platform.OS -eq [OS]::Android) {
|
|
$vswhere = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe"
|
|
$VSInstallPath = & $vswhere -nologo -latest -products * -property installationPath
|
|
if (Test-Path "${VSInstallPath}\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin") {
|
|
$env:Path = "${VSInstallPath}\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin;${VSInstallPath}\Common7\IDE\CommonExtensions\Microsoft\CMake\Ninja;${env:Path}"
|
|
Add-KeyValueIfNew $Defines CMAKE_MAKE_PROGRAM "${VSInstallPath}\Common7\IDE\CommonExtensions\Microsoft\CMake\Ninja\ninja.exe"
|
|
} else {
|
|
throw "Missing CMake and Ninja in the visual studio installation that are needed to build Android"
|
|
}
|
|
$androidNDKPath = Get-AndroidNDKPath
|
|
Add-KeyValueIfNew $Defines CMAKE_C_COMPILER (Join-Path -Path $androidNDKPath -ChildPath "toolchains\llvm\prebuilt\windows-x86_64\bin\clang.exe")
|
|
Add-KeyValueIfNew $Defines CMAKE_CXX_COMPILER (Join-Path -Path $androidNDKPath -ChildPath "toolchains\llvm\prebuilt\windows-x86_64\bin\clang++.exe")
|
|
Add-KeyValueIfNew $Defines CMAKE_ANDROID_API "$AndroidAPILevel"
|
|
Add-KeyValueIfNew $Defines CMAKE_ANDROID_ARCH_ABI $Platform.Architecture.ABI
|
|
Add-KeyValueIfNew $Defines CMAKE_ANDROID_NDK "$androidNDKPath"
|
|
Add-KeyValueIfNew $Defines SWIFT_ANDROID_NDK_PATH "$androidNDKPath"
|
|
Add-KeyValueIfNew $Defines CMAKE_C_COMPILER_WORKS YES
|
|
Add-KeyValueIfNew $Defines CMAKE_CXX_COMPILER_WORKS YES
|
|
}
|
|
|
|
Add-KeyValueIfNew $Defines CMAKE_BUILD_TYPE Release
|
|
|
|
$CFlags = @()
|
|
switch ($Platform.OS) {
|
|
Windows {
|
|
$CFlags = if ($UseGNUDriver) {
|
|
@("-fno-stack-protector", "-ffunction-sections", "-fdata-sections", "-fomit-frame-pointer")
|
|
} else {
|
|
@("/GS-", "/Gw", "/Gy", "/Oi", "/Oy", "/Zc:inline")
|
|
}
|
|
}
|
|
Android {
|
|
$CFlags = @("--sysroot=$(Get-AndroidNDKPath)\toolchains\llvm\prebuilt\windows-x86_64\sysroot")
|
|
}
|
|
}
|
|
|
|
$CXXFlags = @()
|
|
if ($Platform.OS -eq [OS]::Windows -and -not $UseGNUDriver) {
|
|
$CXXFlags += $CFlags.Clone() + @("/Zc:__cplusplus")
|
|
}
|
|
|
|
if ($UseMSVCCompilers.Contains("C") -Or $UseMSVCCompilers.Contains("CXX") -Or
|
|
$UseBuiltCompilers.Contains("C") -Or $UseBuiltCompilers.Contains("CXX") -Or
|
|
$UsePinnedCompilers.Contains("C") -Or $UsePinnedCompilers.Contains("CXX")) {
|
|
if ($DebugInfo -and $Platform.OS -eq [OS]::Windows) {
|
|
Add-FlagsDefine $Defines CMAKE_MSVC_DEBUG_INFORMATION_FORMAT Embedded
|
|
Add-FlagsDefine $Defines CMAKE_POLICY_CMP0141 NEW
|
|
# Add additional linker flags for generating the debug info.
|
|
if ($UseGNUDriver) {
|
|
Add-FlagsDefine $Defines CMAKE_SHARED_LINKER_FLAGS @("-Xlinker", "-debug")
|
|
Add-FlagsDefine $Defines CMAKE_EXE_LINKER_FLAGS @("-Xlinker", "-debug")
|
|
} else {
|
|
Add-FlagsDefine $Defines CMAKE_SHARED_LINKER_FLAGS "/debug"
|
|
Add-FlagsDefine $Defines CMAKE_EXE_LINKER_FLAGS "/debug"
|
|
}
|
|
} elseif ($Platform.OS -eq [OS]::Android) {
|
|
# Use a built lld linker as the Android's NDK linker might be too
|
|
# old and not support all required relocations needed by the Swift
|
|
# runtime.
|
|
$ldPath = ([IO.Path]::Combine((Get-ProjectBinaryCache $BuildPlatform Compilers), "bin", "ld.lld"))
|
|
Add-FlagsDefine $Defines CMAKE_SHARED_LINKER_FLAGS "--ld-path=$ldPath"
|
|
Add-FlagsDefine $Defines CMAKE_EXE_LINKER_FLAGS "--ld-path=$ldPath"
|
|
}
|
|
}
|
|
|
|
if ($UseMSVCCompilers.Contains("C")) {
|
|
Add-KeyValueIfNew $Defines CMAKE_C_COMPILER cl
|
|
if ($EnableCaching) {
|
|
Add-KeyValueIfNew $Defines CMAKE_C_COMPILER_LAUNCHER sccache
|
|
}
|
|
Add-FlagsDefine $Defines CMAKE_C_FLAGS $CFlags
|
|
}
|
|
if ($UseMSVCCompilers.Contains("CXX")) {
|
|
Add-KeyValueIfNew $Defines CMAKE_CXX_COMPILER cl
|
|
if ($EnableCaching) {
|
|
Add-KeyValueIfNew $Defines CMAKE_CXX_COMPILER_LAUNCHER sccache
|
|
}
|
|
Add-FlagsDefine $Defines CMAKE_CXX_FLAGS $CXXFlags
|
|
}
|
|
if ($UsePinnedCompilers.Contains("ASM") -Or $UseBuiltCompilers.Contains("ASM")) {
|
|
$Driver = if ($Platform.OS -eq [OS]::Windows) { "clang-cl.exe" } else { "clang.exe" }
|
|
if ($UseBuiltCompilers.Contains("ASM")) {
|
|
Add-KeyValueIfNew $Defines CMAKE_ASM_COMPILER ([IO.Path]::Combine((Get-ProjectBinaryCache $BuildPlatform Compilers), "bin", $Driver))
|
|
} else {
|
|
Add-KeyValueIfNew $Defines CMAKE_ASM_COMPILER (Join-Path -Path (Get-PinnedToolchainToolsDir) -ChildPath $Driver)
|
|
}
|
|
Add-FlagsDefine $Defines CMAKE_ASM_FLAGS "--target=$($Platform.Triple)"
|
|
if ($Platform.OS -eq [OS]::Windows) {
|
|
Add-KeyValueIfNew $Defines CMAKE_ASM_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDLL "/MD"
|
|
}
|
|
}
|
|
if ($UsePinnedCompilers.Contains("C") -Or $UseBuiltCompilers.Contains("C")) {
|
|
$Driver = if ($Platform.OS -eq [OS]::Windows -and -not $UseGNUDriver) { "clang-cl.exe" } else { "clang.exe" }
|
|
if ($UseBuiltCompilers.Contains("C")) {
|
|
Add-KeyValueIfNew $Defines CMAKE_C_COMPILER ([IO.Path]::Combine((Get-ProjectBinaryCache $BuildPlatform Compilers), "bin", $Driver))
|
|
} else {
|
|
Add-KeyValueIfNew $Defines CMAKE_C_COMPILER (Join-Path -Path (Get-PinnedToolchainToolsDir) -ChildPath $Driver)
|
|
}
|
|
Add-KeyValueIfNew $Defines CMAKE_C_COMPILER_TARGET $Platform.Triple
|
|
|
|
if ($DebugInfo -and $CDebugFormat -eq "dwarf") {
|
|
Add-FlagsDefine $Defines CMAKE_C_FLAGS "-gdwarf"
|
|
}
|
|
Add-FlagsDefine $Defines CMAKE_C_FLAGS $CFlags
|
|
}
|
|
if ($UsePinnedCompilers.Contains("CXX") -Or $UseBuiltCompilers.Contains("CXX")) {
|
|
$Driver = if ($Platform.OS -eq [OS]::Windows -and -not $UseGNUDriver) { "clang-cl.exe" } else { "clang++.exe" }
|
|
if ($UseBuiltCompilers.Contains("CXX")) {
|
|
Add-KeyValueIfNew $Defines CMAKE_CXX_COMPILER ([IO.Path]::Combine((Get-ProjectBinaryCache $BuildPlatform Compilers), "bin", $Driver))
|
|
} else {
|
|
Add-KeyValueIfNew $Defines CMAKE_CXX_COMPILER (Join-Path -Path (Get-PinnedToolchainToolsDir) -ChildPath $Driver)
|
|
}
|
|
Add-KeyValueIfNew $Defines CMAKE_CXX_COMPILER_TARGET $Platform.Triple
|
|
|
|
if ($DebugInfo -and $CDebugFormat -eq "dwarf") {
|
|
Add-FlagsDefine $Defines CMAKE_CXX_FLAGS "-gdwarf"
|
|
}
|
|
Add-FlagsDefine $Defines CMAKE_CXX_FLAGS $CXXFlags
|
|
}
|
|
if ($UsePinnedCompilers.Contains("Swift") -Or $UseBuiltCompilers.Contains("Swift")) {
|
|
$SwiftArgs = @()
|
|
|
|
if ($UseBuiltCompilers.Contains("Swift")) {
|
|
Add-KeyValueIfNew $Defines CMAKE_Swift_COMPILER ([IO.Path]::Combine((Get-ProjectBinaryCache $BuildPlatform Compilers), "bin", "swiftc.exe"))
|
|
} else {
|
|
Add-KeyValueIfNew $Defines CMAKE_Swift_COMPILER (Join-Path -Path (Get-PinnedToolchainToolsDir) -ChildPath "swiftc.exe")
|
|
}
|
|
if (-not ($Platform.OS -eq [OS]::Windows)) {
|
|
Add-KeyValueIfNew $Defines CMAKE_Swift_COMPILER_WORKS = "YES"
|
|
}
|
|
if ($UseBuiltCompilers.Contains("Swift")) {
|
|
Add-KeyValueIfNew $Defines CMAKE_Swift_COMPILER_TARGET (Get-ModuleTriple $Platform)
|
|
$RuntimeBinaryCache = Get-ProjectBinaryCache $BuildPlatform Runtime
|
|
$SwiftResourceDir = "${RuntimeBinaryCache}\lib\swift"
|
|
|
|
switch ($Platform.OS) {
|
|
Windows {
|
|
if ($SwiftSDK -ne "") {
|
|
$SwiftArgs += @("-sdk", $SwiftSDK)
|
|
} else {
|
|
$SwiftArgs += @(
|
|
"-vfsoverlay", "$RuntimeBinaryCache\stdlib\windows-vfs-overlay.yaml",
|
|
"-strict-implicit-module-context",
|
|
"-Xcc", "-Xclang", "-Xcc", "-fbuiltin-headers-in-system-modules"
|
|
)
|
|
$SwiftArgs += @("-resource-dir", "$SwiftResourceDir")
|
|
$SwiftArgs += @("-L", "$SwiftResourceDir\$($_.ToString().ToLowerInvariant())")
|
|
}
|
|
}
|
|
Android {
|
|
$AndroidNDKPath = Get-AndroidNDKPath
|
|
if ($SwiftSDK -ne "") {
|
|
$SwiftArgs += @("-sdk", $SwiftSDK)
|
|
$SwiftArgs += @("-sysroot", "$AndroidNDKPath\toolchains\llvm\prebuilt\windows-x86_64\sysroot")
|
|
} else {
|
|
$SwiftArgs += @("-sdk", "$AndroidNDKPath\toolchains\llvm\prebuilt\windows-x86_64\sysroot")
|
|
$SwiftArgs += @("-resource-dir", "$SwiftResourceDir")
|
|
$SwiftArgs += @("-L", "$SwiftResourceDir\$($_.ToString().ToLowerInvariant())")
|
|
}
|
|
$SwiftArgs += @(
|
|
"-Xclang-linker", "-target",
|
|
"-Xclang-linker", $Platform.Triple,
|
|
"-Xclang-linker", "--sysroot",
|
|
"-Xclang-linker", "$AndroidNDKPath\toolchains\llvm\prebuilt\windows-x86_64\sysroot",
|
|
"-Xclang-linker", "-resource-dir",
|
|
"-Xclang-linker", "$AndroidNDKPath\toolchains\llvm\prebuilt\windows-x86_64\lib\clang\$($(Get-AndroidNDK).ClangVersion)"
|
|
)
|
|
}
|
|
}
|
|
|
|
} else {
|
|
Add-KeyValueIfNew $Defines CMAKE_Swift_COMPILER_TARGET $Platform.Triple
|
|
$SwiftArgs += @("-sdk", (Get-PinnedToolchainSDK))
|
|
}
|
|
|
|
# Debug Information
|
|
if ($DebugInfo) {
|
|
if ($Platform.OS -eq [OS]::Windows) {
|
|
if ($SwiftDebugFormat -eq "dwarf") {
|
|
$SwiftArgs += @("-g", "-Xlinker", "/DEBUG:DWARF", "-use-ld=lld-link")
|
|
} else {
|
|
$SwiftArgs += @("-g", "-debug-info-format=codeview", "-Xlinker", "-debug")
|
|
}
|
|
} else {
|
|
$SwiftArgs += @("-g")
|
|
}
|
|
} else {
|
|
$SwiftArgs += "-gnone"
|
|
}
|
|
|
|
if ($Platform.OS -eq [OS]::Windows) {
|
|
$SwiftArgs += @("-Xlinker", "/INCREMENTAL:NO")
|
|
# Swift requires COMDAT folding and de-duplication
|
|
$SwiftArgs += @("-Xlinker", "/OPT:REF")
|
|
$SwiftArgs += @("-Xlinker", "/OPT:ICF")
|
|
}
|
|
|
|
Add-FlagsDefine $Defines CMAKE_Swift_FLAGS $SwiftArgs
|
|
|
|
# Workaround CMake 3.26+ enabling `-wmo` by default on release builds
|
|
Add-FlagsDefine $Defines CMAKE_Swift_FLAGS_RELEASE "-O"
|
|
Add-FlagsDefine $Defines CMAKE_Swift_FLAGS_RELWITHDEBINFO "-O"
|
|
}
|
|
if ($InstallTo) {
|
|
Add-KeyValueIfNew $Defines CMAKE_INSTALL_PREFIX $InstallTo
|
|
}
|
|
|
|
# Generate the project
|
|
$cmakeGenerateArgs = @("-B", $Bin, "-S", $Src, "-G", $Generator)
|
|
if ($CacheScript) {
|
|
$cmakeGenerateArgs += @("-C", $CacheScript)
|
|
}
|
|
foreach ($Define in ($Defines.GetEnumerator() | Sort-Object Name)) {
|
|
# The quoting gets tricky to support defines containing compiler flags args,
|
|
# some of which can contain spaces, for example `-D` `Flags=-flag "C:/Program Files"`
|
|
# Avoid backslashes since they are going into CMakeCache.txt,
|
|
# where they are interpreted as escapes.
|
|
if ($Define.Value -is [string]) {
|
|
# Single token value, no need to quote spaces, the splat operator does the right thing.
|
|
$Value = $Define.Value.Replace("\", "/")
|
|
} else {
|
|
# Flags array, multiple tokens, quoting needed for tokens containing spaces
|
|
$Value = ""
|
|
foreach ($Arg in $Define.Value) {
|
|
if ($Value.Length -gt 0) {
|
|
$Value += " "
|
|
}
|
|
|
|
$ArgWithForwardSlashes = $Arg.Replace("\", "/")
|
|
if ($ArgWithForwardSlashes.Contains(" ")) {
|
|
# Quote and escape the quote so it makes it through
|
|
$Value += "\""$ArgWithForwardSlashes\"""
|
|
} else {
|
|
$Value += $ArgWithForwardSlashes
|
|
}
|
|
}
|
|
}
|
|
|
|
$cmakeGenerateArgs += @("-D", "$($Define.Key)=$Value")
|
|
}
|
|
|
|
if ($UseBuiltCompilers.Contains("Swift")) {
|
|
$env:Path = "$([IO.Path]::Combine((Get-InstallDir $BuildPlatform), "Runtimes", $ProductVersion, "usr", "bin"));$(Get-CMarkBinaryCache $BuildPlatform)\src;$($BuildPlatform.ToolchainInstallRoot)\usr\bin;$(Get-PinnedToolchainRuntime);${env:Path}"
|
|
} elseif ($UsePinnedCompilers.Contains("Swift")) {
|
|
$env:Path = "$(Get-PinnedToolchainRuntime);${env:Path}"
|
|
}
|
|
|
|
if ($ToBatch) {
|
|
Write-Output ""
|
|
Write-Output "echo cmake.exe $cmakeGenerateArgs"
|
|
} else {
|
|
Write-Host "cmake.exe $cmakeGenerateArgs"
|
|
}
|
|
Invoke-Program cmake.exe @cmakeGenerateArgs
|
|
|
|
# Build all requested targets
|
|
foreach ($Target in $BuildTargets) {
|
|
if ($Target -eq "default") {
|
|
Invoke-Program cmake.exe --build $Bin
|
|
} else {
|
|
Invoke-Program cmake.exe --build $Bin --target $Target
|
|
}
|
|
}
|
|
|
|
if ($BuildTargets.Length -eq 0 -and $InstallTo) {
|
|
Invoke-Program cmake.exe --build $Bin --target install
|
|
}
|
|
}
|
|
|
|
if (-not $ToBatch) {
|
|
Write-Host -ForegroundColor Cyan "[$([DateTime]::Now.ToString("yyyy-MM-dd HH:mm:ss"))] Finished building '$Src' to '$Bin' in $($Stopwatch.Elapsed)"
|
|
Write-Host ""
|
|
}
|
|
}
|
|
|
|
enum SPMBuildAction {
|
|
# 'swift build'
|
|
Build
|
|
# 'swift test'
|
|
Test
|
|
# 'swift test --parallel'
|
|
TestParallel
|
|
}
|
|
|
|
function Build-SPMProject {
|
|
[CmdletBinding(PositionalBinding = $false)]
|
|
param
|
|
(
|
|
[SPMBuildAction] $Action,
|
|
[string] $Src,
|
|
[string] $Bin,
|
|
[hashtable] $Platform,
|
|
[string] $Configuration = "release",
|
|
[Parameter(ValueFromRemainingArguments)]
|
|
[string[]] $AdditionalArguments
|
|
)
|
|
|
|
$ActionForOutput = switch ($Action) {
|
|
Build { "Building" }
|
|
Test { "Testing" }
|
|
TestParallel { "Testing" }
|
|
}
|
|
|
|
if ($ToBatch) {
|
|
Write-Output ""
|
|
Write-Output "echo $ActionForOutput '$Src' to '$Bin' ..."
|
|
} else {
|
|
Write-Host -ForegroundColor Cyan "[$([DateTime]::Now.ToString("yyyy-MM-dd HH:mm:ss"))] $ActionForOutput '$Src' to '$Bin' ..."
|
|
}
|
|
|
|
$Stopwatch = [Diagnostics.Stopwatch]::StartNew()
|
|
|
|
Invoke-IsolatingEnvVars {
|
|
$RuntimeInstallRoot = [IO.Path]::Combine((Get-InstallDir $HostPlatform), "Runtimes", $ProductVersion)
|
|
|
|
$env:Path = "$RuntimeInstallRoot\usr\bin;$($HostPlatform.ToolchainInstallRoot)\usr\bin;${env:Path}"
|
|
$env:SDKROOT = (Get-SwiftSDK Windows)
|
|
$env:SWIFTCI_USE_LOCAL_DEPS = "1"
|
|
|
|
$Arguments = @(
|
|
"--scratch-path", $Bin,
|
|
"--package-path", $Src,
|
|
"-c", $Configuration,
|
|
"-Xbuild-tools-swiftc", "-I$(Get-SwiftSDK Windows)\usr\lib\swift",
|
|
"-Xbuild-tools-swiftc", "-L$(Get-SwiftSDK Windows)\usr\lib\swift\windows",
|
|
"-Xcc", "-I$(Get-SwiftSDK Windows)\usr\lib\swift",
|
|
"-Xlinker", "-L$(Get-SwiftSDK Windows)\usr\lib\swift\windows"
|
|
)
|
|
if ($DebugInfo) {
|
|
if ($SwiftDebugFormat -eq "dwarf") {
|
|
$Arguments += @("-debug-info-format", "dwarf")
|
|
} else {
|
|
$Arguments += @("-debug-info-format", "codeview")
|
|
}
|
|
} else {
|
|
$Arguments += @("-debug-info-format", "none")
|
|
}
|
|
|
|
switch ($Action) {
|
|
Build {
|
|
$ActionName = "build"
|
|
}
|
|
Test {
|
|
$ActionName = "test"
|
|
}
|
|
TestParallel {
|
|
$ActionName = "test"
|
|
$Arguments += @("--parallel")
|
|
}
|
|
}
|
|
|
|
Invoke-Program "$($HostPlatform.ToolchainInstallRoot)\usr\bin\swift.exe" $ActionName @Arguments @AdditionalArguments
|
|
}
|
|
|
|
if (-not $ToBatch) {
|
|
Write-Host -ForegroundColor Cyan "[$([DateTime]::Now.ToString("yyyy-MM-dd HH:mm:ss"))] Finished building '$Src' to '$Bin' in $($Stopwatch.Elapsed)"
|
|
Write-Host ""
|
|
}
|
|
}
|
|
|
|
function Build-WiXProject() {
|
|
[CmdletBinding(PositionalBinding = $false)]
|
|
param
|
|
(
|
|
[Parameter(Position = 0, Mandatory = $true)]
|
|
[string]$FileName,
|
|
[Parameter(Mandatory = $true)]
|
|
[hashtable]$Platform,
|
|
[switch]$Bundle,
|
|
[hashtable]$Properties = @{}
|
|
)
|
|
|
|
$ProductVersionArg = $ProductVersion
|
|
if (-not $Bundle) {
|
|
# WiX v4 will accept a semantic version string for Bundles,
|
|
# but Packages still require a purely numerical version number,
|
|
# so trim any semantic versioning suffixes
|
|
$ProductVersionArg = [regex]::Replace($ProductVersion, "[-+].*", "")
|
|
}
|
|
|
|
$Properties = $Properties.Clone()
|
|
Add-KeyValueIfNew $Properties Configuration Release
|
|
Add-KeyValueIfNew $Properties BaseOutputPath "$BinaryCache\$($Platform.Triple)\installer\"
|
|
Add-KeyValueIfNew $Properties ProductArchitecture $Platform.Architecture.VSName
|
|
Add-KeyValueIfNew $Properties ProductVersion $ProductVersionArg
|
|
|
|
$MSBuildArgs = @("$SourceCache\swift-installer-scripts\platforms\Windows\$FileName")
|
|
$MSBuildArgs += "-noLogo"
|
|
$MSBuildArgs += "-restore"
|
|
$MSBuildArgs += "-maxCpuCount"
|
|
foreach ($Property in $Properties.GetEnumerator()) {
|
|
if ($Property.Value.Contains(" ")) {
|
|
$MSBuildArgs += "-p:$($Property.Key)=$($Property.Value.Replace('\', '\\'))"
|
|
} else {
|
|
$MSBuildArgs += "-p:$($Property.Key)=$($Property.Value)"
|
|
}
|
|
}
|
|
$MSBuildArgs += "-binaryLogger:$BinaryCache\$($Platform.Triple)\msi\$($Platform.Architecture.VSName)-$([System.IO.Path]::GetFileNameWithoutExtension($FileName)).binlog"
|
|
$MSBuildArgs += "-detailedSummary:False"
|
|
|
|
Invoke-Program $msbuild @MSBuildArgs
|
|
}
|
|
|
|
# TODO(compnerd): replace this with Get-{Build,Host,Target}ProjectBinaryCache
|
|
function Get-CMarkBinaryCache([Hashtable] $Platform) {
|
|
return "$BinaryCache\$($Platform.Triple)\cmark-gfm-0.29.0.gfm.13"
|
|
}
|
|
|
|
function Build-CMark([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\cmark `
|
|
-Bin (Get-CMarkBinaryCache $Platform) `
|
|
-InstallTo "$($Platform.ToolchainInstallRoot)\usr" `
|
|
-Platform $Platform `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "YES";
|
|
BUILD_TESTING = "NO";
|
|
CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP = "YES";
|
|
}
|
|
}
|
|
|
|
function Build-BuildTools([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\llvm-project\llvm `
|
|
-Bin (Get-ProjectBinaryCache $Platform BuildTools) `
|
|
-Platform $Platform `
|
|
-UseMSVCCompilers C,CXX `
|
|
-BuildTargets llvm-tblgen,clang-tblgen,clang-pseudo-gen,clang-tidy-confusable-chars-gen,lldb-tblgen,llvm-config,swift-def-to-strings-converter,swift-serialize-diagnostics,swift-compatibility-symbols `
|
|
-Defines @{
|
|
CMAKE_CROSSCOMPILING = "NO";
|
|
CLANG_ENABLE_LIBXML2 = "NO";
|
|
LLDB_ENABLE_LIBXML2 = "NO";
|
|
LLDB_ENABLE_PYTHON = "NO";
|
|
LLDB_INCLUDE_TESTS = "NO";
|
|
LLDB_ENABLE_SWIFT_SUPPORT = "NO";
|
|
LLVM_ENABLE_ASSERTIONS = "NO";
|
|
LLVM_ENABLE_LIBEDIT = "NO";
|
|
LLVM_ENABLE_LIBXML2 = "NO";
|
|
LLVM_ENABLE_PROJECTS = "clang;clang-tools-extra;lldb";
|
|
LLVM_EXTERNAL_PROJECTS = "swift";
|
|
LLVM_EXTERNAL_SWIFT_SOURCE_DIR = "$SourceCache\swift";
|
|
SWIFT_BUILD_DYNAMIC_SDK_OVERLAY = "NO";
|
|
SWIFT_BUILD_DYNAMIC_STDLIB = "NO";
|
|
SWIFT_BUILD_HOST_DISPATCH = "NO";
|
|
SWIFT_BUILD_LIBEXEC = "NO";
|
|
SWIFT_BUILD_REGEX_PARSER_IN_COMPILER = "NO";
|
|
SWIFT_BUILD_REMOTE_MIRROR = "NO";
|
|
SWIFT_BUILD_SOURCEKIT = "NO";
|
|
SWIFT_BUILD_STATIC_SDK_OVERLAY = "NO";
|
|
SWIFT_BUILD_STATIC_STDLIB = "NO";
|
|
SWIFT_BUILD_SWIFT_SYNTAX = "NO";
|
|
SWIFT_ENABLE_DISPATCH = "NO";
|
|
SWIFT_INCLUDE_APINOTES = "NO";
|
|
SWIFT_INCLUDE_DOCS = "NO";
|
|
SWIFT_INCLUDE_TESTS = "NO";
|
|
"cmark-gfm_DIR" = "$($Platform.ToolchainInstallRoot)\usr\lib\cmake";
|
|
}
|
|
}
|
|
|
|
function Write-PList {
|
|
[CmdletBinding(PositionalBinding = $false)]
|
|
param
|
|
(
|
|
[Parameter(Mandatory = $true)]
|
|
[PSCustomObject] $Settings,
|
|
[Parameter(Mandatory = $true)]
|
|
[string] $Path
|
|
)
|
|
|
|
Invoke-Program "$(Get-PythonExecutable)" -c "import plistlib; print(str(plistlib.dumps($(($Settings | ConvertTo-JSON -Compress) -replace '"', "'")), encoding='utf-8'))" `
|
|
-OutFile $Path
|
|
}
|
|
|
|
function Load-LitTestOverrides($Filename) {
|
|
function Select-LitTestOverrides($Prefix) {
|
|
$MatchingLines = Get-Content $Filename | Select-String -Pattern "`^${Prefix}.*$"
|
|
return $MatchingLines | ForEach-Object { ($_ -replace $Prefix,"").Trim() }
|
|
}
|
|
|
|
$TestsToXFail = Select-LitTestOverrides "xfail"
|
|
Write-Host "TestsToXFail=$TestsToXFail"
|
|
if ($TestsToXFail -and $TestsToXFail.Length -ne 0) {
|
|
$env:LIT_XFAIL = $TestsToXFail -join ";"
|
|
}
|
|
$TestsToSkip = Select-LitTestOverrides "skip"
|
|
Write-Host "TestsToSkip=$TestsToSkip"
|
|
if ($TestsToSkip -and $TestsToSkip.Length -gt 0) {
|
|
$env:LIT_FILTER_OUT = "($($TestsToSkip -join '|'))"
|
|
}
|
|
}
|
|
|
|
function Get-CompilersDefines([Hashtable] $Platform, [switch] $Test) {
|
|
$BuildTools = [IO.Path]::Combine((Get-ProjectBinaryCache $BuildPlatform BuildTools), "bin")
|
|
$PythonRoot = [IO.Path]::Combine((Get-PythonPath $Platform), "tools")
|
|
$PythonLibName = "python{0}{1}" -f ([System.Version]$PythonVersion).Major, ([System.Version]$PythonVersion).Minor
|
|
|
|
$TestDefines = if ($Test) {
|
|
@{
|
|
SWIFT_BUILD_DYNAMIC_SDK_OVERLAY = "YES";
|
|
SWIFT_BUILD_DYNAMIC_STDLIB = "YES";
|
|
SWIFT_BUILD_REMOTE_MIRROR = "YES";
|
|
SWIFT_NATIVE_SWIFT_TOOLS_PATH = "";
|
|
}
|
|
} else {
|
|
@{
|
|
SWIFT_BUILD_DYNAMIC_SDK_OVERLAY = "NO";
|
|
SWIFT_BUILD_DYNAMIC_STDLIB = "NO";
|
|
SWIFT_BUILD_REMOTE_MIRROR = "NO";
|
|
SWIFT_NATIVE_SWIFT_TOOLS_PATH = $BuildTools;
|
|
}
|
|
}
|
|
|
|
# If DebugInfo is enabled limit the number of parallel links to avoid OOM.
|
|
$DebugDefines = if ($DebugInfo) { @{ SWIFT_PARALLEL_LINK_JOBS = "4"; } } else { @{} }
|
|
|
|
# In the latest versions of VS, STL typically requires a newer version of
|
|
# Clang than released Swift toolchains include. Relax this requirement when
|
|
# bootstrapping with an older toolchain. Note developer builds are (currently)
|
|
# up-to-date.
|
|
$SwiftFlags = @();
|
|
if ([System.Version](Get-PinnedToolchainVersion) -ne [System.Version]"0.0.0") {
|
|
$SwiftFlags += @("-Xcc", "-D_ALLOW_COMPILER_AND_STL_VERSION_MISMATCH");
|
|
}
|
|
|
|
return $TestDefines + $DebugDefines + @{
|
|
CLANG_TABLEGEN = (Join-Path -Path $BuildTools -ChildPath "clang-tblgen.exe");
|
|
CLANG_TIDY_CONFUSABLE_CHARS_GEN = (Join-Path -Path $BuildTools -ChildPath "clang-tidy-confusable-chars-gen.exe");
|
|
CMAKE_FIND_PACKAGE_PREFER_CONFIG = "YES";
|
|
CMAKE_Swift_FLAGS = $SwiftFlags;
|
|
LibXml2_DIR = "$LibraryRoot\libxml2-2.11.5\usr\lib\Windows\$($Platform.Architecture.LLVMName)\cmake\libxml2-2.11.5";
|
|
LLDB_PYTHON_EXE_RELATIVE_PATH = "python.exe";
|
|
LLDB_PYTHON_EXT_SUFFIX = ".pyd";
|
|
LLDB_PYTHON_RELATIVE_PATH = "lib/site-packages";
|
|
LLDB_TABLEGEN = (Join-Path -Path $BuildTools -ChildPath "lldb-tblgen.exe");
|
|
LLDB_TEST_MAKE = "$BinaryCache\GnuWin32Make-4.4.1\bin\make.exe";
|
|
LLVM_CONFIG_PATH = (Join-Path -Path $BuildTools -ChildPath "llvm-config.exe");
|
|
LLVM_ENABLE_ASSERTIONS = $(if ($Variant -eq "Asserts") { "YES" } else { "NO" })
|
|
LLVM_EXTERNAL_SWIFT_SOURCE_DIR = "$SourceCache\swift";
|
|
LLVM_HOST_TRIPLE = $BuildPlatform.Triple;
|
|
LLVM_NATIVE_TOOL_DIR = $BuildTools;
|
|
LLVM_TABLEGEN = (Join-Path $BuildTools -ChildPath "llvm-tblgen.exe");
|
|
LLVM_USE_HOST_TOOLS = "NO";
|
|
Python3_EXECUTABLE = (Get-PythonExecutable);
|
|
Python3_INCLUDE_DIR = "$PythonRoot\include";
|
|
Python3_LIBRARY = "$PythonRoot\libs\$PythonLibName.lib";
|
|
Python3_ROOT_DIR = $PythonRoot;
|
|
SWIFT_BUILD_SWIFT_SYNTAX = "YES";
|
|
SWIFT_CLANG_LOCATION = (Get-PinnedToolchainToolsDir);
|
|
SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY = "YES";
|
|
SWIFT_ENABLE_EXPERIMENTAL_CXX_INTEROP = "YES";
|
|
SWIFT_ENABLE_EXPERIMENTAL_DIFFERENTIABLE_PROGRAMMING = "YES";
|
|
SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED = "YES";
|
|
SWIFT_ENABLE_EXPERIMENTAL_OBSERVATION = "YES";
|
|
SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING = "YES";
|
|
SWIFT_ENABLE_SYNCHRONIZATION = "YES";
|
|
SWIFT_ENABLE_VOLATILE = "YES";
|
|
SWIFT_PATH_TO_LIBDISPATCH_SOURCE = "$SourceCache\swift-corelibs-libdispatch";
|
|
SWIFT_PATH_TO_STRING_PROCESSING_SOURCE = "$SourceCache\swift-experimental-string-processing";
|
|
SWIFT_PATH_TO_SWIFT_SDK = (Get-PinnedToolchainSDK);
|
|
SWIFT_PATH_TO_SWIFT_SYNTAX_SOURCE = "$SourceCache\swift-syntax";
|
|
SWIFT_STDLIB_ASSERTIONS = "NO";
|
|
SWIFTSYNTAX_ENABLE_ASSERTIONS = "NO";
|
|
"cmark-gfm_DIR" = "$($Platform.ToolchainInstallRoot)\usr\lib\cmake";
|
|
}
|
|
}
|
|
|
|
function Build-Compilers([Hashtable] $Platform) {
|
|
New-Item -ItemType SymbolicLink -Path "$BinaryCache\$($HostPlatform.Triple)\compilers" -Target "$BinaryCache\5" -ErrorAction Ignore
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\llvm-project\llvm `
|
|
-Bin (Get-ProjectBinaryCache $Platform Compilers) `
|
|
-InstallTo "$($Platform.ToolchainInstallRoot)\usr" `
|
|
-Platform $Platform `
|
|
-UseMSVCCompilers C,CXX `
|
|
-UsePinnedCompilers Swift `
|
|
-BuildTargets @("install-distribution") `
|
|
-CacheScript $SourceCache\swift\cmake\caches\Windows-$($Platform.Architecture.LLVMName).cmake `
|
|
-Defines (Get-CompilersDefines $Platform)
|
|
|
|
$Settings = @{
|
|
FallbackLibrarySearchPaths = @("usr/bin")
|
|
Identifier = "${ToolchainIdentifier}"
|
|
Version = "${ProductVersion}"
|
|
}
|
|
Write-PList -Settings $Settings -Path "$($Platform.ToolchainInstallRoot)\ToolchainInfo.plist"
|
|
}
|
|
|
|
function Test-Compilers([Hashtable] $Platform, [switch] $TestClang, [switch] $TestLLD, [switch] $TestLLDB, [switch] $TestLLVM, [switch] $TestSwift) {
|
|
Invoke-IsolatingEnvVars {
|
|
$env:Path = "$(Get-CMarkBinaryCache $Platform)\src;$(Get-ProjectBinaryCache $BuildPlatform Compilers)\tools\swift\libdispatch-windows-$($Platform.Architecture.LLVMName)-prefix\bin;$(Get-ProjectBinaryCache $BuildPlatform Compilers)\bin;$env:Path;$VSInstallRoot\DIA SDK\bin\$($HostPlatform.Architecture.VSName);$UnixToolsBinDir"
|
|
$TestingDefines = Get-CompilersDefines $Platform -Test
|
|
if ($TestLLVM) { $Targets += @("check-llvm") }
|
|
if ($TestClang) { $Targets += @("check-clang") }
|
|
if ($TestLLD) { $Targets += @("check-lld") }
|
|
if ($TestSwift) { $Targets += @("check-swift", "SwiftCompilerPlugin") }
|
|
if ($TestLLDB) {
|
|
$Targets += @("check-lldb")
|
|
|
|
# Override test filter for known issues in downstream LLDB
|
|
Load-LitTestOverrides $PSScriptRoot/windows-llvm-lit-test-overrides.txt
|
|
|
|
# Transitive dependency of _lldb.pyd
|
|
$RuntimeBinaryCache = Get-ProjectBinaryCache $BuildPlatform Runtime
|
|
Copy-Item $RuntimeBinaryCache\bin\swiftCore.dll "$(Get-ProjectBinaryCache $BuildPlatform Compilers)\lib\site-packages\lldb"
|
|
|
|
# Runtime dependencies of repl_swift.exe
|
|
$SwiftRTSubdir = "lib\swift\windows"
|
|
Write-Host "Copying '$RuntimeBinaryCache\$SwiftRTSubdir\$($Platform.Architecture.LLVMName)\swiftrt.obj' to '$(Get-ProjectBinaryCache $BuildPlatform Compilers)\$SwiftRTSubdir'"
|
|
Copy-Item "$RuntimeBinaryCache\$SwiftRTSubdir\$($Platform.Architecture.LLVMName)\swiftrt.obj" "$(Get-ProjectBinaryCache $BuildPlatform Compilers)\$SwiftRTSubdir"
|
|
Write-Host "Copying '$RuntimeBinaryCache\bin\swiftCore.dll' to '$(Get-ProjectBinaryCache $BuildPlatform Compilers)\bin'"
|
|
Copy-Item "$RuntimeBinaryCache\bin\swiftCore.dll" "$(Get-ProjectBinaryCache $BuildPlatform Compilers)\bin"
|
|
|
|
$TestingDefines += @{
|
|
LLDB_INCLUDE_TESTS = "YES";
|
|
# Check for required Python modules in CMake
|
|
LLDB_ENFORCE_STRICT_TEST_REQUIREMENTS = "YES";
|
|
# No watchpoint support on windows: https://github.com/llvm/llvm-project/issues/24820
|
|
LLDB_TEST_USER_ARGS = "--skip-category=watchpoint";
|
|
# gtest sharding breaks llvm-lit's --xfail and LIT_XFAIL inputs: https://github.com/llvm/llvm-project/issues/102264
|
|
LLVM_LIT_ARGS = "-v --no-gtest-sharding --show-xfail";
|
|
# LLDB Unit tests link against this library
|
|
LLVM_UNITTEST_LINK_FLAGS = "$(Get-SwiftSDK Windows)\usr\lib\swift\windows\$($Platform.Architecture.LLVMName)\swiftCore.lib";
|
|
}
|
|
}
|
|
|
|
if (-not $Targets) {
|
|
Write-Warning "Test-Compilers invoked without specifying test target(s)."
|
|
}
|
|
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\llvm-project\llvm `
|
|
-Bin $(Get-ProjectBinaryCache $Platform Compilers) `
|
|
-InstallTo "$($Platform.ToolchainInstallRoot)\usr" `
|
|
-Platform $Platform `
|
|
-UseMSVCCompilers C,CXX `
|
|
-UsePinnedCompilers Swift `
|
|
-BuildTargets $Targets `
|
|
-CacheScript $SourceCache\swift\cmake\caches\Windows-$($Platform.Architecture.LLVMName).cmake `
|
|
-Defines $TestingDefines
|
|
}
|
|
}
|
|
|
|
# Reference: https://github.com/microsoft/mimalloc/tree/dev/bin#minject
|
|
function Build-mimalloc() {
|
|
[CmdletBinding(PositionalBinding = $false)]
|
|
param
|
|
(
|
|
[Parameter(Position = 0, Mandatory = $true)]
|
|
[hashtable]$Platform
|
|
)
|
|
|
|
# TODO: migrate to the CMake build
|
|
$MSBuildArgs = @()
|
|
$MSBuildArgs += "-noLogo"
|
|
$MSBuildArgs += "-maxCpuCount"
|
|
|
|
$Properties = @{}
|
|
Add-KeyValueIfNew $Properties Configuration Release
|
|
Add-KeyValueIfNew $Properties OutDir "$BinaryCache\$($Platform.Triple)\mimalloc\bin\"
|
|
Add-KeyValueIfNew $Properties Platform "$($Platform.Architecture.ShortName)"
|
|
|
|
Invoke-IsolatingEnvVars {
|
|
Invoke-VsDevShell $Platform
|
|
# Avoid hard-coding the VC tools version number
|
|
$VCRedistDir = (Get-ChildItem "${env:VCToolsRedistDir}\$($HostPlatform.Architecture.ShortName)" -Filter "Microsoft.VC*.CRT").FullName
|
|
if ($VCRedistDir) {
|
|
Add-KeyValueIfNew $Properties VCRedistDir "$VCRedistDir\"
|
|
}
|
|
}
|
|
|
|
foreach ($Property in $Properties.GetEnumerator()) {
|
|
if ($Property.Value.Contains(" ")) {
|
|
$MSBuildArgs += "-p:$($Property.Key)=$($Property.Value.Replace('\', '\\'))"
|
|
} else {
|
|
$MSBuildArgs += "-p:$($Property.Key)=$($Property.Value)"
|
|
}
|
|
}
|
|
|
|
Invoke-Program $msbuild "$SourceCache\mimalloc\ide\vs2022\mimalloc-lib.vcxproj" @MSBuildArgs "-p:IntDir=$BinaryCache\$($Platform.Triple)\mimalloc\mimalloc\"
|
|
Invoke-Program $msbuild "$SourceCache\mimalloc\ide\vs2022\mimalloc-override-dll.vcxproj" @MSBuildArgs "-p:IntDir=$BinaryCache\$($Platform.Triple)\mimalloc\mimalloc-override-dll\"
|
|
|
|
$HostSuffix = if ($Platform -eq $KnownPlatforms["WindowsX64"]) { "" } else { "-arm64" }
|
|
$BuildSuffix = if ($BuildPlatform -eq $KnownPlatforms["WindowsX64"]) { "" } else { "-arm64" }
|
|
|
|
foreach ($item in "mimalloc.dll", "mimalloc-redirect$HostSuffix.dll") {
|
|
Copy-Item -Path "$BinaryCache\$($Platform.Triple)\mimalloc\bin\$item" -Destination "$($Platform.ToolchainInstallRoot)\usr\bin\"
|
|
}
|
|
|
|
# When cross-compiling, bundle the second mimalloc redirect dll as a workaround for
|
|
# https://github.com/microsoft/mimalloc/issues/997
|
|
if ($IsCrossCompiling) {
|
|
Copy-Item -Path "$BinaryCache\$($Platform.Triple)\mimalloc\bin\mimalloc-redirect$HostSuffix.dll" -Destination "$($Platform.ToolchainInstallRoot)\usr\bin\mimalloc-redirect$BuildSuffix.dll"
|
|
}
|
|
|
|
# TODO: should we split this out into its own function?
|
|
$Tools = @(
|
|
"swift.exe",
|
|
"swiftc.exe",
|
|
"swift-driver.exe",
|
|
"swift-frontend.exe",
|
|
"clang.exe",
|
|
"clang++.exe",
|
|
"clang-cl.exe",
|
|
"lld.exe",
|
|
"lld-link.exe",
|
|
"ld.lld.exe",
|
|
"ld64.lld.exe"
|
|
)
|
|
foreach ($Tool in $Tools) {
|
|
$Binary = [IO.Path]::Combine($Platform.ToolchainInstallRoot, "usr", "bin", $Tool)
|
|
# Binary-patch in place
|
|
Invoke-Program "$SourceCache\mimalloc\bin\minject$BuildSuffix" "-f" "-i" "$Binary"
|
|
# Log the import table
|
|
$LogFile = "$BinaryCache\$($Platform.Triple)\mimalloc\minject-log-$Tool.txt"
|
|
$ErrorFile = "$BinaryCache\$($Platform.Triple)\mimalloc\minject-log-$Tool-error.txt"
|
|
Invoke-Program "$SourceCache\mimalloc\bin\minject$BuildSuffix" "-l" "$Binary" -OutFile $LogFile -ErrorFile $ErrorFile
|
|
# Verify patching
|
|
$Found = Select-String -Path $LogFile -Pattern "mimalloc"
|
|
if (-not $Found) {
|
|
Get-Content $ErrorFile
|
|
throw "Failed to patch mimalloc for $Tool"
|
|
}
|
|
}
|
|
}
|
|
|
|
function Build-LLVM([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\llvm-project\llvm `
|
|
-Bin (Get-ProjectBinaryCache $Platform LLVM) `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers C,CXX `
|
|
-Defines @{
|
|
CMAKE_SYSTEM_NAME = $Platform.OS.ToString();
|
|
LLVM_HOST_TRIPLE = $Platform.Triple;
|
|
}
|
|
}
|
|
|
|
function Build-Sanitizers([Hashtable] $Platform) {
|
|
$LLVMTargetCache = $(Get-ProjectBinaryCache $Platform LLVM)
|
|
$LITVersionStr = $(Invoke-Program $(Get-PythonExecutable) "$LLVMTargetCache\bin\llvm-lit.py" --version)
|
|
if (-not ($LITVersionStr -match "lit (\d+)\.\d+\.\d+.*")) {
|
|
throw "Unexpected version string output from llvm-lit.py"
|
|
}
|
|
$LLVMVersionMajor = $Matches.1
|
|
$InstallTo = "$($HostPlatform.ToolchainInstallRoot)\usr\lib\clang\$LLVMVersionMajor"
|
|
Write-Host "Sanitizers SDK directory: $InstallTo"
|
|
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\llvm-project\compiler-rt\lib\builtins `
|
|
-Bin "$(Get-ProjectBinaryCache $Platform ClangBuiltins)" `
|
|
-InstallTo $InstallTo `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers ASM,C,CXX `
|
|
-BuildTargets "install-compiler-rt" `
|
|
-Defines (@{
|
|
CMAKE_SYSTEM_NAME = $Platform.OS.ToString();
|
|
LLVM_DIR = "$LLVMTargetCache\lib\cmake\llvm";
|
|
LLVM_ENABLE_PER_TARGET_RUNTIME_DIR = "YES";
|
|
COMPILER_RT_DEFAULT_TARGET_ONLY = "YES";
|
|
})
|
|
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\llvm-project\compiler-rt `
|
|
-Bin "$(Get-ProjectBinaryCache $Platform ClangRuntime)" `
|
|
-InstallTo $InstallTo `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers ASM,C,CXX `
|
|
-BuildTargets "install-compiler-rt" `
|
|
-Defines (@{
|
|
CMAKE_SYSTEM_NAME = $Platform.OS.ToString();
|
|
LLVM_DIR = "$LLVMTargetCache\lib\cmake\llvm";
|
|
LLVM_ENABLE_PER_TARGET_RUNTIME_DIR = "YES";
|
|
COMPILER_RT_DEFAULT_TARGET_ONLY = "YES";
|
|
COMPILER_RT_BUILD_BUILTINS = "NO";
|
|
COMPILER_RT_BUILD_CRT = "NO";
|
|
COMPILER_RT_BUILD_LIBFUZZER = "NO";
|
|
COMPILER_RT_BUILD_ORC = "NO";
|
|
COMPILER_RT_BUILD_XRAY = "NO";
|
|
COMPILER_RT_BUILD_PROFILE = "YES";
|
|
COMPILER_RT_BUILD_SANITIZERS = "YES";
|
|
})
|
|
}
|
|
|
|
function Build-ZLib([Hashtable] $Platform) {
|
|
$ArchName = $Platform.Architecture.LLVMName
|
|
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\zlib `
|
|
-Bin "$BinaryCache\$($Platform.Triple)\zlib-1.3.1" `
|
|
-InstallTo $LibraryRoot\zlib-1.3.1\usr `
|
|
-Platform $Platform `
|
|
-UseMSVCCompilers C `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "NO";
|
|
CMAKE_POSITION_INDEPENDENT_CODE = "YES";
|
|
CMAKE_SYSTEM_NAME = $Platform.OS.ToString();
|
|
INSTALL_BIN_DIR = "$LibraryRoot\zlib-1.3.1\usr\bin\$($Platform.OS.ToString())\$ArchName";
|
|
INSTALL_LIB_DIR = "$LibraryRoot\zlib-1.3.1\usr\lib\$($Platform.OS.ToString())\$ArchName";
|
|
}
|
|
}
|
|
|
|
function Build-XML2([Hashtable] $Platform) {
|
|
$ArchName = $Platform.Architecture.LLVMName
|
|
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\libxml2 `
|
|
-Bin "$BinaryCache\$($Platform.Triple)\libxml2-2.11.5" `
|
|
-InstallTo "$LibraryRoot\libxml2-2.11.5\usr" `
|
|
-Platform $Platform `
|
|
-UseMSVCCompilers C,CXX `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "NO";
|
|
CMAKE_INSTALL_BINDIR = "bin/$($Platform.OS.ToString())/$ArchName";
|
|
CMAKE_INSTALL_LIBDIR = "lib/$($Platform.OS.ToString())/$ArchName";
|
|
CMAKE_POSITION_INDEPENDENT_CODE = "YES";
|
|
CMAKE_SYSTEM_NAME = $Platform.OS.ToString();
|
|
LIBXML2_WITH_ICONV = "NO";
|
|
LIBXML2_WITH_ICU = "NO";
|
|
LIBXML2_WITH_LZMA = "NO";
|
|
LIBXML2_WITH_PYTHON = "NO";
|
|
LIBXML2_WITH_TESTS = "NO";
|
|
LIBXML2_WITH_THREADS = "YES";
|
|
LIBXML2_WITH_ZLIB = "NO";
|
|
}
|
|
}
|
|
|
|
function Build-RegsGen2([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\ds2\Tools\RegsGen2 `
|
|
-Bin (Get-ProjectBinaryCache $Platform RegsGen2) `
|
|
-Platform $Platform `
|
|
-BuildTargets default `
|
|
-UseMSVCCompilers C,CXX `
|
|
-Defines @{
|
|
BISON_EXECUTABLE = "$(Get-BisonExecutable)";
|
|
FLEX_EXECUTABLE = "$(Get-FlexExecutable)";
|
|
}
|
|
}
|
|
|
|
function Build-DS2([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src "$SourceCache\ds2" `
|
|
-Bin "$BinaryCache\$($Platform.Triple)\ds2" `
|
|
-InstallTo "$(Get-PlatformRoot $Platform.OS)\Developer\Library\ds2\usr" `
|
|
-Platform $Platform `
|
|
-Defines @{
|
|
CMAKE_SYSTEM_NAME = $Platform.OS.ToString();
|
|
DS2_REGSGEN2 = "$(Get-ProjectBinaryCache $BuildPlatform RegsGen2)/regsgen2.exe";
|
|
DS2_PROGRAM_PREFIX = "$(Get-ModuleTriple $Platform)-";
|
|
BISON_EXECUTABLE = "$(Get-BisonExecutable)";
|
|
FLEX_EXECUTABLE = "$(Get-FlexExecutable)";
|
|
}
|
|
}
|
|
|
|
function Build-CURL([Hashtable] $Platform) {
|
|
$ArchName = $Platform.Architecture.LLVMName
|
|
|
|
$PlatformDefines = @{}
|
|
if ($Platform.OS -eq [OS]::Android) {
|
|
$PlatformDefines += @{
|
|
HAVE_FSEEKO = "0";
|
|
}
|
|
}
|
|
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\curl `
|
|
-Bin "$BinaryCache\$($Platform.Triple)\curl-8.9.1" `
|
|
-InstallTo "$LibraryRoot\curl-8.9.1\usr" `
|
|
-Platform $Platform `
|
|
-UseMSVCCompilers C `
|
|
-Defines ($PlatformDefines + @{
|
|
BUILD_SHARED_LIBS = "NO";
|
|
BUILD_TESTING = "NO";
|
|
CMAKE_INSTALL_LIBDIR = "lib/$($Platform.OS.ToString())/$ArchName";
|
|
CMAKE_POSITION_INDEPENDENT_CODE = "YES";
|
|
CMAKE_SYSTEM_NAME = $Platform.OS.ToString();
|
|
BUILD_CURL_EXE = "NO";
|
|
BUILD_LIBCURL_DOCS = "NO";
|
|
BUILD_MISC_DOCS = "NO";
|
|
CURL_CA_BUNDLE = "none";
|
|
CURL_CA_FALLBACK = "NO";
|
|
CURL_CA_PATH = "none";
|
|
CURL_BROTLI = "NO";
|
|
CURL_DISABLE_ALTSVC = "NO";
|
|
CURL_DISABLE_AWS = "YES";
|
|
CURL_DISABLE_BASIC_AUTH = "NO";
|
|
CURL_DISABLE_BEARER_AUTH = "NO";
|
|
CURL_DISABLE_BINDLOCAL = "NO";
|
|
CURL_DISABLE_COOKIES = "NO";
|
|
CURL_DISABLE_DICT = "YES";
|
|
CURL_DISABLE_DIGEST_AUTH = "NO";
|
|
CURL_DISABLE_DOH = "NO";
|
|
CURL_DISABLE_FILE = "YES";
|
|
CURL_DISABLE_FORM_API = "NO";
|
|
CURL_DISABLE_FTP = "YES";
|
|
CURL_DISABLE_GETOPTIONS = "NO";
|
|
CURL_DISABLE_GOPHER = "YES";
|
|
CURL_DISABLE_HEADERS_API = "YES";
|
|
CURL_DISABLE_HSTS = "NO";
|
|
CURL_DISABLE_HTTP = "NO";
|
|
CURL_DISABLE_HTTP_AUTH = "NO";
|
|
CURL_DISABLE_IMAP = "YES";
|
|
CURL_DISABLE_KERBEROS_AUTH = "NO";
|
|
CURL_DISABLE_LDAP = "YES";
|
|
CURL_DISABLE_LDAPS = "YES";
|
|
CURL_DISABLE_MIME = "NO";
|
|
CURL_DISABLE_MQTT = "YES";
|
|
CURL_DISABLE_NEGOTIATE_AUTH = "NO";
|
|
CURL_DISABLE_NETRC = "NO";
|
|
CURL_DISABLE_NTLM = "NO";
|
|
CURL_DISABLE_PARSEDATE = "NO";
|
|
CURL_DISABLE_POP3 = "YES";
|
|
CURL_DISABLE_PROGRESS_METER = "YES";
|
|
CURL_DISABLE_PROXY = "NO";
|
|
CURL_DISABLE_RTSP = "YES";
|
|
CURL_DISABLE_SHUFFLE_DNS = "YES";
|
|
CURL_DISABLE_SMB = "YES";
|
|
CURL_DISABLE_SMTP = "YES";
|
|
CURL_DISABLE_SOCKETPAIR = "YES";
|
|
CURL_DISABLE_SRP = "NO";
|
|
CURL_DISABLE_TELNET = "YES";
|
|
CURL_DISABLE_TFTP = "YES";
|
|
CURL_DISABLE_VERBOSE_STRINGS = "NO";
|
|
CURL_LTO = "NO";
|
|
CURL_USE_BEARSSL = "NO";
|
|
CURL_USE_GNUTLS = "NO";
|
|
CURL_USE_GSSAPI = "NO";
|
|
CURL_USE_LIBPSL = "NO";
|
|
CURL_USE_LIBSSH = "NO";
|
|
CURL_USE_LIBSSH2 = "NO";
|
|
CURL_USE_MBEDTLS = "NO";
|
|
CURL_USE_OPENSSL = "NO";
|
|
CURL_USE_SCHANNEL = if ($Platform.OS -eq [OS]::Windows) { "YES" } else { "NO" };
|
|
CURL_USE_WOLFSSL = "NO";
|
|
CURL_WINDOWS_SSPI = if ($Platform.OS -eq [OS]::Windows) { "YES" } else { "NO" };
|
|
CURL_ZLIB = "YES";
|
|
CURL_ZSTD = "NO";
|
|
ENABLE_ARES = "NO";
|
|
ENABLE_CURLDEBUG = "NO";
|
|
ENABLE_CURL_MANUAL = "NO";
|
|
ENABLE_DEBUG = "NO";
|
|
ENABLE_IPV6 = "YES";
|
|
ENABLE_THREADED_RESOLVER = "NO";
|
|
ENABLE_UNICODE = "YES";
|
|
ENABLE_UNIX_SOCKETS = "NO";
|
|
ENABLE_WEBSOCKETS = "YES";
|
|
HAVE_POLL_FINE = "NO";
|
|
USE_ECH = "NO";
|
|
USE_HTTPSRR = "NO";
|
|
USE_IDN2 = "NO";
|
|
USE_MSH3 = "NO";
|
|
USE_NGHTTP2 = "NO";
|
|
USE_NGTCP2 = "NO";
|
|
USE_QUICHE = "NO";
|
|
USE_OPENSSL_QUIC = "NO";
|
|
USE_WIN32_IDN = if ($Platform.OS -eq [OS]::Windows) { "YES" } else { "NO" };
|
|
USE_WIN32_LARGE_FILES = if ($Platform.OS -eq [OS]::Windows) { "YES" } else { "NO" };
|
|
USE_WIN32_LDAP = "NO";
|
|
ZLIB_ROOT = "$LibraryRoot\zlib-1.3.1\usr";
|
|
ZLIB_LIBRARY = "$LibraryRoot\zlib-1.3.1\usr\lib\$($Platform.OS.ToString())\$ArchName\zlibstatic.lib";
|
|
})
|
|
}
|
|
|
|
function Build-Runtime([Hashtable] $Platform) {
|
|
$PlatformDefines = @{}
|
|
if ($Platform.OS -eq [OS]::Android) {
|
|
$PlatformDefines += @{
|
|
LLVM_ENABLE_LIBCXX = "YES";
|
|
SWIFT_USE_LINKER = "lld";
|
|
# Clang[<18] doesn't provide the _Builtin_float module.
|
|
SWIFT_BUILD_CLANG_OVERLAYS_SKIP_BUILTIN_FLOAT = "YES";
|
|
}
|
|
}
|
|
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift `
|
|
-Bin (Get-ProjectBinaryCache $Platform Runtime) `
|
|
-InstallTo "$(Get-SwiftSDK $Platform.OS)\usr" `
|
|
-Platform $Platform `
|
|
-CacheScript $SourceCache\swift\cmake\caches\Runtime-$($Platform.OS.ToString())-$($Platform.Architecture.LLVMName).cmake `
|
|
-UseBuiltCompilers C,CXX,Swift `
|
|
-Defines ($PlatformDefines + @{
|
|
CMAKE_Swift_COMPILER_TARGET = (Get-ModuleTriple $Platform);
|
|
CMAKE_Swift_COMPILER_WORKS = "YES";
|
|
CMAKE_SYSTEM_NAME = $Platform.OS.ToString();
|
|
LLVM_DIR = "$(Get-ProjectBinaryCache $Platform LLVM)\lib\cmake\llvm";
|
|
SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY = "YES";
|
|
SWIFT_ENABLE_EXPERIMENTAL_CXX_INTEROP = "YES";
|
|
SWIFT_ENABLE_EXPERIMENTAL_DIFFERENTIABLE_PROGRAMMING = "YES";
|
|
SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED = "YES";
|
|
SWIFT_ENABLE_EXPERIMENTAL_OBSERVATION = "YES";
|
|
SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING = "YES";
|
|
SWIFT_ENABLE_SYNCHRONIZATION = "YES";
|
|
SWIFT_ENABLE_VOLATILE = "YES";
|
|
SWIFT_NATIVE_SWIFT_TOOLS_PATH = ([IO.Path]::Combine((Get-ProjectBinaryCache $BuildPlatform Compilers), "bin"));
|
|
SWIFT_PATH_TO_LIBDISPATCH_SOURCE = "$SourceCache\swift-corelibs-libdispatch";
|
|
SWIFT_PATH_TO_STRING_PROCESSING_SOURCE = "$SourceCache\swift-experimental-string-processing";
|
|
CMAKE_SHARED_LINKER_FLAGS = if ($Platform.OS -eq [OS]::Windows) { @("/INCREMENTAL:NO", "/OPT:REF", "/OPT:ICF") } else { @() };
|
|
})
|
|
}
|
|
|
|
function Test-Runtime([Hashtable] $Platform) {
|
|
if ($IsCrossCompiling) {
|
|
throw "Swift runtime tests are not supported when cross-compiling"
|
|
}
|
|
if (-not (Test-Path (Get-ProjectBinaryCache $Platform Runtime))) {
|
|
throw "Swift runtime tests are supposed to reconfigure the existing build"
|
|
}
|
|
$CompilersBinaryCache = Get-ProjectBinaryCache $BuildPlatform Compilers
|
|
if (-not (Test-Path "$CompilersBinaryCache\bin\FileCheck.exe")) {
|
|
# These will exist if we test any of llvm/clang/lldb/lld/swift as well
|
|
throw "LIT test utilities not found in $CompilersBinaryCache\bin"
|
|
}
|
|
|
|
Invoke-IsolatingEnvVars {
|
|
# Filter known issues when testing on Windows
|
|
Load-LitTestOverrides $PSScriptRoot/windows-swift-android-lit-test-overrides.txt
|
|
$env:Path = "$(Get-CMarkBinaryCache $Platform)\src;$(Get-PinnedToolchainRuntime);${env:Path};$UnixToolsBinDir"
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift `
|
|
-Bin (Get-ProjectBinaryCache $Platform Runtime) `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers C,CXX,Swift `
|
|
-BuildTargets check-swift-validation-only_non_executable `
|
|
-Defines @{
|
|
SWIFT_INCLUDE_TESTS = "YES";
|
|
SWIFT_INCLUDE_TEST_BINARIES = "YES";
|
|
SWIFT_BUILD_TEST_SUPPORT_MODULES = "YES";
|
|
SWIFT_NATIVE_LLVM_TOOLS_PATH = Join-Path -Path $CompilersBinaryCache -ChildPath "bin";
|
|
LLVM_LIT_ARGS = "-vv";
|
|
}
|
|
}
|
|
}
|
|
|
|
function Build-ExperimentalRuntime {
|
|
[CmdletBinding(PositionalBinding = $false)]
|
|
param
|
|
(
|
|
[Parameter(Position = 0, Mandatory = $true)]
|
|
[Hashtable] $Platform,
|
|
[switch] $Static = $false
|
|
)
|
|
|
|
# TODO: remove this once the migration is completed.
|
|
Invoke-IsolatingEnvVars {
|
|
Invoke-VsDevShell $BuildPlatform
|
|
|
|
Push-Location "${SourceCache}\swift\Runtimes"
|
|
Start-Process -Wait -WindowStyle Hidden -FilePath cmake.exe -ArgumentList @("-P", "Resync.cmake")
|
|
Pop-Location
|
|
}
|
|
|
|
Invoke-IsolatingEnvVars {
|
|
$env:Path = "$(Get-CMarkBinaryCache $Platform)\src;$(Get-PinnedToolchainRuntime);${env:Path}"
|
|
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift\Runtimes\Core `
|
|
-Bin (Get-ProjectBinaryCache $Platform ExperimentalRuntime) `
|
|
-InstallTo "$(Get-SwiftSDK $Platform.OS -Identifier "$($Platform.OS)Experimental")\usr" `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers C,CXX,Swift `
|
|
-UseGNUDriver `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = if ($Static) { "NO" } else { "YES" };
|
|
CMAKE_FIND_PACKAGE_PREFER_CONFIG = "YES";
|
|
CMAKE_Swift_COMPILER_TARGET = (Get-ModuleTriple $Platform);
|
|
CMAKE_Swift_COMPILER_WORKS = "YES";
|
|
CMAKE_STATIC_LIBRARY_PREFIX_Swift = "lib";
|
|
CMAKE_SYSTEM_NAME = $Platform.OS.ToString();
|
|
dispatch_DIR = (Get-ProjectCMakeModules $Platform Dispatch);
|
|
SwiftCore_ENABLE_CONCURRENCY = "YES";
|
|
}
|
|
}
|
|
}
|
|
|
|
function Write-SDKSettingsPlist([Hashtable] $Platform) {
|
|
$SDKSettings = @{
|
|
DefaultProperties = @{
|
|
}
|
|
}
|
|
if ($Platform.OS -eq [OS]::Windows) {
|
|
$SDKSettings.DefaultProperties.DEFAULT_USE_RUNTIME = "MD"
|
|
}
|
|
Write-PList -Settings $SDKSettings -Path "$(Get-SwiftSDK $Platform.OS)\SDKSettings.plist"
|
|
|
|
$SDKSettings = @{
|
|
CanonicalName = "$($Platform.Triple)"
|
|
DisplayName = "$($Platform.OS.ToString())"
|
|
IsBaseSDK = "NO"
|
|
Version = "${ProductVersion}"
|
|
VersionMap = @{}
|
|
DefaultProperties = @{
|
|
PLATFORM_NAME = "$($Platform.OS.ToString())"
|
|
DEFAULT_COMPILER = "${ToolchainIdentifier}"
|
|
}
|
|
}
|
|
if ($Platform.OS -eq [OS]::Windows) {
|
|
$SDKSettings.DefaultProperties.DEFAULT_USE_RUNTIME = "MD"
|
|
}
|
|
$SDKSettings | ConvertTo-JSON | Out-FIle -FilePath "$(Get-SwiftSDK $Platform.OS)\SDKSettings.json"
|
|
}
|
|
|
|
function Build-Dispatch([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-corelibs-libdispatch `
|
|
-Bin (Get-ProjectBinaryCache $Platform Dispatch) `
|
|
-InstallTo "$(Get-SwiftSDK $Platform.OS)\usr" `
|
|
-Platform $Platform `
|
|
-SwiftSDK (Get-SwiftSDK $Platform.OS) `
|
|
-UseBuiltCompilers C,CXX,Swift `
|
|
-Defines @{
|
|
ENABLE_SWIFT = "YES";
|
|
}
|
|
}
|
|
|
|
function Test-Dispatch {
|
|
Invoke-IsolatingEnvVars {
|
|
$env:CTEST_OUTPUT_ON_FAILURE = "YES"
|
|
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-corelibs-libdispatch `
|
|
-Bin (Get-ProjectBinaryCache $BuildPlatform Dispatch) `
|
|
-Platform $BuildPlatform `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-BuildTargets default,ExperimentalTest `
|
|
-UseBuiltCompilers C,CXX,Swift `
|
|
-Defines @{
|
|
ENABLE_SWIFT = "YES";
|
|
}
|
|
}
|
|
}
|
|
|
|
function Build-Foundation {
|
|
[CmdletBinding(PositionalBinding = $false)]
|
|
param
|
|
(
|
|
[Parameter(Position = 0, Mandatory = $true)]
|
|
[Hashtable] $Platform,
|
|
[switch] $Static = $false
|
|
)
|
|
|
|
$FoundationBinaryCache = if ($Static) {
|
|
Get-ProjectBinaryCache $Platform StaticFoundation
|
|
} else {
|
|
Get-ProjectBinaryCache $Platform DynamicFoundation
|
|
}
|
|
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-corelibs-foundation `
|
|
-Bin $FoundationBinaryCache `
|
|
-InstallTo $(if ($Static) { "$(Get-SwiftSDK $Platform.OS -Identifier "$($Platform.OS)Experimental")\usr" } else { "$(Get-SwiftSDK $Platform.OS)\usr" }) `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers ASM,C,CXX,Swift `
|
|
-SwiftSDK (Get-SwiftSDK $Platform.OS) `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = if ($Static) { "NO" } else { "YES" };
|
|
CMAKE_FIND_PACKAGE_PREFER_CONFIG = "YES";
|
|
CMAKE_NINJA_FORCE_RESPONSE_FILE = "YES";
|
|
CMAKE_STATIC_LIBRARY_PREFIX_Swift = "lib";
|
|
ENABLE_TESTING = "NO";
|
|
FOUNDATION_BUILD_TOOLS = if ($Platform.OS -eq [OS]::Windows) { "YES" } else { "NO" };
|
|
CURL_DIR = "$LibraryRoot\curl-8.9.1\usr\lib\$($Platform.OS.ToString())\$($Platform.Architecture.LLVMName)\cmake\CURL";
|
|
LibXml2_DIR = "$LibraryRoot\libxml2-2.11.5\usr\lib\$($Platform.OS.ToString())\$($Platform.Architecture.LLVMName)\cmake\libxml2-2.11.5";
|
|
ZLIB_LIBRARY = if ($Platform.OS -eq [OS]::Windows) {
|
|
"$LibraryRoot\zlib-1.3.1\usr\lib\$($Platform.OS.ToString())\$($Platform.Architecture.LLVMName)\zlibstatic.lib"
|
|
} else {
|
|
"$LibraryRoot\zlib-1.3.1\usr\lib\$($Platform.OS.ToString())\$($Platform.Architecture.LLVMName)\libz.a"
|
|
};
|
|
ZLIB_INCLUDE_DIR = "$LibraryRoot\zlib-1.3.1\usr\include";
|
|
dispatch_DIR = (Get-ProjectCMakeModules $Platform Dispatch);
|
|
SwiftSyntax_DIR = (Get-ProjectBinaryCache $HostPlatform Compilers);
|
|
_SwiftFoundation_SourceDIR = "$SourceCache\swift-foundation";
|
|
_SwiftFoundationICU_SourceDIR = "$SourceCache\swift-foundation-icu";
|
|
_SwiftCollections_SourceDIR = "$SourceCache\swift-collections";
|
|
SwiftFoundation_MACRO = "$(Get-ProjectBinaryCache $BuildPlatform FoundationMacros)\bin"
|
|
}
|
|
}
|
|
|
|
function Test-Foundation {
|
|
# Foundation tests build via swiftpm rather than CMake
|
|
Build-SPMProject `
|
|
-Action Test `
|
|
-Src $SourceCache\swift-foundation `
|
|
-Bin "$BinaryCache\$($BuildPlatform.Triple)\CoreFoundationTests" `
|
|
-Platform $BuildPlatform
|
|
|
|
Invoke-IsolatingEnvVars {
|
|
$env:DISPATCH_INCLUDE_PATH="$(Get-SwiftSDK Windows)/usr/include"
|
|
$env:LIBXML_LIBRARY_PATH="$LibraryRoot/libxml2-2.11.5/usr/lib/windows/$($BuildPlatform.Architecture.LLVMName)"
|
|
$env:LIBXML_INCLUDE_PATH="$LibraryRoot/libxml2-2.11.5/usr/include/libxml2"
|
|
$env:ZLIB_LIBRARY_PATH="$LibraryRoot/zlib-1.3.1/usr/lib/windows/$($BuildPlatform.Architecture.LLVMName)"
|
|
$env:CURL_LIBRARY_PATH="$LibraryRoot/curl-8.9.1/usr/lib/windows/$($BuildPlatform.Architecture.LLVMName)"
|
|
$env:CURL_INCLUDE_PATH="$LibraryRoot/curl-8.9.1/usr/include"
|
|
Build-SPMProject `
|
|
-Action Test `
|
|
-Src $SourceCache\swift-corelibs-foundation `
|
|
-Bin "$BinaryCache\$($BuildPlatform.Triple)\FoundationTests" `
|
|
-Platform $BuildPlatform `
|
|
-Configuration $FoundationTestConfiguration
|
|
}
|
|
}
|
|
|
|
function Build-FoundationMacros([Hashtable] $Platform) {
|
|
$SwiftSyntaxDir = (Get-ProjectCMakeModules $Platform Compilers)
|
|
if (-not (Test-Path $SwiftSyntaxDir)) {
|
|
throw "The swift-syntax from the compiler build for $($Platform.OS) $($Platform.Architecture.ShortName) isn't available"
|
|
}
|
|
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-foundation\Sources\FoundationMacros `
|
|
-Bin (Get-ProjectBinaryCache $Platform FoundationMacros) `
|
|
-InstallTo "$($Platform.ToolchainInstallRoot)\usr" `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers Swift `
|
|
-SwiftSDK (Get-SwiftSDK $Platform.OS) `
|
|
-Defines @{
|
|
SwiftSyntax_DIR = $SwiftSyntaxDir;
|
|
}
|
|
}
|
|
|
|
function Build-XCTest([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-corelibs-xctest `
|
|
-Bin (Get-ProjectBinaryCache $Platform XCTest) `
|
|
-InstallTo "$([IO.Path]::Combine((Get-PlatformRoot $Platform.OS), "Developer", "Library", "XCTest-$ProductVersion", "usr"))" `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers Swift `
|
|
-SwiftSDK (Get-SwiftSDK $Platform.OS) `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "YES";
|
|
CMAKE_BUILD_WITH_INSTALL_RPATH = "YES";
|
|
CMAKE_INSTALL_BINDIR = $Platform.BinaryDir;
|
|
ENABLE_TESTING = "NO";
|
|
dispatch_DIR = $(Get-ProjectCMakeModules $Platform Dispatch);
|
|
Foundation_DIR = $(Get-ProjectCMakeModules $Platform DynamicFoundation);
|
|
XCTest_INSTALL_NESTED_SUBDIR = "YES";
|
|
}
|
|
}
|
|
|
|
function Test-XCTest {
|
|
Invoke-IsolatingEnvVars {
|
|
$env:Path = "$(Get-ProjectBinaryCache $BuildPlatform XCTest);$(Get-ProjectBinaryCache $BuildPlatform DynamicFoundation)\bin;$(Get-ProjectBinaryCache $BuildPlatform Dispatch);$(Get-ProjectBinaryCache $BuildPlatform Runtime)\bin;${env:Path};$UnixToolsBinDir"
|
|
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-corelibs-xctest `
|
|
-Bin (Get-ProjectBinaryCache $BuildPlatform XCTest) `
|
|
-Platform $BuildPlatform `
|
|
-UseBuiltCompilers Swift `
|
|
-BuildTargets default,check-xctest `
|
|
-Defines @{
|
|
CMAKE_BUILD_WITH_INSTALL_RPATH = "YES";
|
|
ENABLE_TESTING = "YES";
|
|
dispatch_DIR = $(Get-ProjectCMakeModules $BuildPlatform Dispatch);
|
|
Foundation_DIR = $(Get-ProjectCMakeModules $BuildPlatform DynamicFoundation);
|
|
LLVM_DIR = "$(Get-ProjectBinaryCache $BuildPlatform LLVM)\lib\cmake\llvm";
|
|
XCTEST_PATH_TO_FOUNDATION_BUILD = $(Get-ProjectBinaryCache $BuildPlatform DynamicFoundation);
|
|
XCTEST_PATH_TO_LIBDISPATCH_BUILD = $(Get-ProjectBinaryCache $BuildPlatform Dispatch);
|
|
XCTEST_PATH_TO_LIBDISPATCH_SOURCE = "$SourceCache\swift-corelibs-libdispatch";
|
|
}
|
|
}
|
|
}
|
|
|
|
function Build-Testing([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-testing `
|
|
-Bin (Get-ProjectBinaryCache $Platform Testing) `
|
|
-InstallTo "$([IO.Path]::Combine((Get-PlatformRoot $Platform.OS), "Developer", "Library", "Testing-$ProductVersion", "usr"))" `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers C,CXX,Swift `
|
|
-SwiftSDK (Get-SwiftSDK $Platform.OS) `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "YES";
|
|
CMAKE_BUILD_WITH_INSTALL_RPATH = "YES";
|
|
CMAKE_INSTALL_BINDIR = $Platform.BinaryDir;
|
|
dispatch_DIR = (Get-ProjectCMakeModules $Platform Dispatch);
|
|
Foundation_DIR = (Get-ProjectCMakeModules $Platform DynamicFoundation);
|
|
SwiftSyntax_DIR = (Get-ProjectBinaryCache $HostPlatform Compilers);
|
|
SwiftTesting_MACRO = "$(Get-ProjectBinaryCache $BuildPlatform TestingMacros)\TestingMacros.dll";
|
|
SwiftTesting_INSTALL_NESTED_SUBDIR = "YES";
|
|
}
|
|
}
|
|
|
|
function Test-Testing {
|
|
throw "testing Testing is not supported"
|
|
}
|
|
|
|
function Write-PlatformInfoPlist([Hashtable] $Platform) {
|
|
$Settings = @{
|
|
DefaultProperties = @{
|
|
SWIFT_TESTING_VERSION = "$ProductVersion"
|
|
XCTEST_VERSION = "$ProductVersion"
|
|
}
|
|
}
|
|
if ($Platform.OS -eq [OS]::Windows) {
|
|
$Settings.DefaultProperties.SWIFTC_FLAGS = @( "-use-ld=lld" )
|
|
}
|
|
|
|
Write-PList -Settings $Settings -Path "$(Get-PlatformRoot $Platform.OS)\Info.plist"
|
|
}
|
|
|
|
# Copies files installed by CMake from the arch-specific platform root,
|
|
# where they follow the layout expected by the installer,
|
|
# to the final platform root, following the installer layout.
|
|
function Install-Platform([Hashtable[]] $Platforms, [OS] $OS) {
|
|
# Copy SDK header files
|
|
foreach ($Module in ("Block", "dispatch", "os", "_foundation_unicode", "_FoundationCShims")) {
|
|
$ModuleDirectory = "$(Get-SwiftSDK $OS)\usr\lib\swift\$Module"
|
|
if (Test-Path $ModuleDirectory) {
|
|
Move-Directory $ModuleDirectory "$(Get-SwiftSDK $OS)\usr\include\"
|
|
}
|
|
}
|
|
|
|
# Copy files from the arch subdirectory, including "*.swiftmodule" which need restructuring
|
|
foreach ($Platform in $Platforms) {
|
|
$PlatformResources = "$(Get-SwiftSDK $Platform.OS)\usr\lib\swift\$($Platform.OS.ToString().ToLowerInvariant())"
|
|
Get-ChildItem -Recurse "$PlatformResources\$($Platform.Architecture.LLVMName)" | ForEach-Object {
|
|
if (".swiftmodule", ".swiftdoc", ".swiftinterface" -contains $_.Extension) {
|
|
Copy-File $_.FullName "$PlatformResources\$($_.BaseName).swiftmodule\$(Get-ModuleTriple $Platform)$($_.Extension)"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function Build-SQLite([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-toolchain-sqlite `
|
|
-Bin "$BinaryCache\$($Platform.Triple)\sqlite-3.46.0" `
|
|
-InstallTo $LibraryRoot\sqlite-3.46.0\usr `
|
|
-Platform $Platform `
|
|
-UseMSVCCompilers C `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "NO";
|
|
}
|
|
}
|
|
|
|
function Build-System([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-system `
|
|
-Bin (Get-ProjectBinaryCache $Platform System) `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers C,Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-BuildTargets default `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "NO";
|
|
CMAKE_STATIC_LIBRARY_PREFIX_Swift = "lib";
|
|
}
|
|
}
|
|
|
|
function Build-Build([Hashtable] $Platform) {
|
|
# Use lld to workaround the ARM64 LNK1322 issue: https://github.com/swiftlang/swift/issues/79740
|
|
# FIXME(hjyamauchi) Have a real fix
|
|
$ArchSpecificOptions = if ($Platform -eq $KnownPlatforms["WindowsARM64"]) { @{ CMAKE_Swift_FLAGS = "-use-ld=lld-link"; } } else { @{} }
|
|
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-build `
|
|
-Bin (Get-ProjectBinaryCache $Platform Build) `
|
|
-InstallTo "$($Platform.ToolchainInstallRoot)\usr" `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers C,CXX,Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-Defines (@{
|
|
BUILD_SHARED_LIBS = "YES";
|
|
CMAKE_STATIC_LIBRARY_PREFIX_Swift = "lib";
|
|
ArgumentParser_DIR = (Get-ProjectCMakeModules $Platform ArgumentParser);
|
|
LLBuild_DIR = (Get-ProjectCMakeModules $Platform LLBuild);
|
|
SwiftDriver_DIR = (Get-ProjectCMakeModules $Platform Driver);
|
|
SwiftSystem_DIR = (Get-ProjectCMakeModules $Platform System);
|
|
TSC_DIR = (Get-ProjectCMakeModules $Platform ToolsSupportCore);
|
|
SQLite3_INCLUDE_DIR = "$LibraryRoot\sqlite-3.46.0\usr\include";
|
|
SQLite3_LIBRARY = "$LibraryRoot\sqlite-3.46.0\usr\lib\SQLite3.lib";
|
|
} + $ArchSpecificOptions)
|
|
}
|
|
|
|
function Build-ToolsSupportCore([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-tools-support-core `
|
|
-Bin (Get-ProjectBinaryCache $Platform ToolsSupportCore) `
|
|
-InstallTo "$($Platform.ToolchainInstallRoot)\usr" `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers C,Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "YES";
|
|
CMAKE_STATIC_LIBRARY_PREFIX_Swift = "lib";
|
|
}
|
|
}
|
|
|
|
function Build-LLBuild([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\llbuild `
|
|
-Bin (Get-ProjectBinaryCache $Platform LLBuild) `
|
|
-InstallTo "$($Platform.ToolchainInstallRoot)\usr" `
|
|
-Platform $Platform `
|
|
-UseMSVCCompilers CXX `
|
|
-UseBuiltCompilers Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "YES";
|
|
LLBUILD_SUPPORT_BINDINGS = "Swift";
|
|
SQLite3_INCLUDE_DIR = "$LibraryRoot\sqlite-3.46.0\usr\include";
|
|
SQLite3_LIBRARY = "$LibraryRoot\sqlite-3.46.0\usr\lib\SQLite3.lib";
|
|
}
|
|
}
|
|
|
|
function Test-LLBuild {
|
|
# Build additional llvm executables needed by tests
|
|
Invoke-IsolatingEnvVars {
|
|
Invoke-VsDevShell $BuildPlatform
|
|
Invoke-Program ninja.exe -C (Get-ProjectBinaryCache $BuildPlatform BuildTools) FileCheck not
|
|
}
|
|
|
|
Invoke-IsolatingEnvVars {
|
|
$env:Path = "$env:Path;$UnixToolsBinDir"
|
|
$env:AR = ([IO.Path]::Combine((Get-ProjectBinaryCache $BuildPlatform Compilers), "bin", "llvm-ar.exe"))
|
|
$env:CLANG = ([IO.Path]::Combine((Get-ProjectBinaryCache $BuildPlatform Compilers), "bin", "clang.exe"))
|
|
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\llbuild `
|
|
-Bin (Get-ProjectBinaryCache $BuildPlatform LLBuild) `
|
|
-Platform $Platform `
|
|
-UseMSVCCompilers CXX `
|
|
-UseBuiltCompilers Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-BuildTargets default,test-llbuild `
|
|
-Defines = @{
|
|
BUILD_SHARED_LIBS = "YES";
|
|
FILECHECK_EXECUTABLE = ([IO.Path]::Combine((Get-ProjectBinaryCache $BuildPlatform BuildTools), "bin", "FileCheck.exe"));
|
|
LIT_EXECUTABLE = "$SourceCache\llvm-project\llvm\utils\lit\lit.py";
|
|
LLBUILD_SUPPORT_BINDINGS = "Swift";
|
|
SQLite3_INCLUDE_DIR = "$LibraryRoot\sqlite-3.46.0\usr\include";
|
|
SQLite3_LIBRARY = "$LibraryRoot\sqlite-3.46.0\usr\lib\SQLite3.lib";
|
|
}
|
|
}
|
|
}
|
|
|
|
function Build-ArgumentParser([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-argument-parser `
|
|
-Bin (Get-ProjectBinaryCache $Platform ArgumentParser) `
|
|
-InstallTo "$($Platform.ToolchainInstallRoot)\usr" `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "YES";
|
|
BUILD_TESTING = "NO";
|
|
CMAKE_STATIC_LIBRARY_PREFIX_Swift = "lib";
|
|
}
|
|
}
|
|
|
|
function Build-Driver([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-driver `
|
|
-Bin (Get-ProjectBinaryCache $Platform Driver) `
|
|
-InstallTo "$($Platform.ToolchainInstallRoot)\usr" `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers C,CXX,Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "YES";
|
|
CMAKE_STATIC_LIBRARY_PREFIX_Swift = "lib";
|
|
TSC_DIR = (Get-ProjectCMakeModules $Platform ToolsSupportCore);
|
|
LLBuild_DIR = (Get-ProjectCMakeModules $Platform LLBuild);
|
|
ArgumentParser_DIR = (Get-ProjectCMakeModules $Platform ArgumentParser);
|
|
SQLite3_INCLUDE_DIR = "$LibraryRoot\sqlite-3.46.0\usr\include";
|
|
SQLite3_LIBRARY = "$LibraryRoot\sqlite-3.46.0\usr\lib\SQLite3.lib";
|
|
SWIFT_DRIVER_BUILD_TOOLS = "YES";
|
|
LLVM_DIR = "$(Get-ProjectBinaryCache $Platform Compilers)\lib\cmake\llvm";
|
|
Clang_DIR = "$(Get-ProjectBinaryCache $Platform Compilers)\lib\cmake\clang";
|
|
Swift_DIR = "$(Get-ProjectBinaryCache $Platform Compilers)\tools\swift\lib\cmake\swift";
|
|
}
|
|
}
|
|
|
|
function Build-Crypto([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-crypto `
|
|
-Bin (Get-ProjectBinaryCache $Platform Crypto) `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-BuildTargets default `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "NO";
|
|
CMAKE_STATIC_LIBRARY_PREFIX_Swift = "lib";
|
|
}
|
|
}
|
|
|
|
function Build-Collections([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-collections `
|
|
-Bin (Get-ProjectBinaryCache $Platform Collections) `
|
|
-InstallTo "$($Platform.ToolchainInstallRoot)\usr" `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers C,Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "YES";
|
|
CMAKE_STATIC_LIBRARY_PREFIX_Swift = "lib";
|
|
}
|
|
}
|
|
|
|
function Build-ASN1([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-asn1 `
|
|
-Bin (Get-ProjectBinaryCache $Platform ASN1) `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-BuildTargets default `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "NO";
|
|
CMAKE_STATIC_LIBRARY_PREFIX_Swift = "lib";
|
|
}
|
|
}
|
|
|
|
function Build-Certificates([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-certificates `
|
|
-Bin (Get-ProjectBinaryCache $Platform Certificates) `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-BuildTargets default `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "NO";
|
|
CMAKE_STATIC_LIBRARY_PREFIX_Swift = "lib";
|
|
SwiftCrypto_DIR = (Get-ProjectCMakeModules $Platform Crypto);
|
|
SwiftASN1_DIR = (Get-ProjectCMakeModules $Platform ASN1);
|
|
}
|
|
}
|
|
|
|
function Build-PackageManager([Hashtable] $Platform) {
|
|
$SrcDir = if (Test-Path -Path "$SourceCache\swift-package-manager" -PathType Container) {
|
|
"$SourceCache\swift-package-manager"
|
|
} else {
|
|
"$SourceCache\swiftpm"
|
|
}
|
|
|
|
Build-CMakeProject `
|
|
-Src $SrcDir `
|
|
-Bin (Get-ProjectBinaryCache $Platform PackageManager) `
|
|
-InstallTo "$($Platform.ToolchainInstallRoot)\usr" `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers C,Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "YES";
|
|
CMAKE_Swift_FLAGS = @("-DCRYPTO_v2");
|
|
CMAKE_STATIC_LIBRARY_PREFIX_Swift = "lib";
|
|
SwiftSystem_DIR = (Get-ProjectCMakeModules $Platform System);
|
|
TSC_DIR = (Get-ProjectCMakeModules $Platform ToolsSupportCore);
|
|
LLBuild_DIR = (Get-ProjectCMakeModules $Platform LLBuild);
|
|
ArgumentParser_DIR = (Get-ProjectCMakeModules $Platform ArgumentParser);
|
|
SwiftDriver_DIR = (Get-ProjectCMakeModules $Platform Driver);
|
|
SwiftCrypto_DIR = (Get-ProjectCMakeModules $Platform Crypto);
|
|
SwiftCollections_DIR = (Get-ProjectCMakeModules $Platform Collections);
|
|
SwiftASN1_DIR = (Get-ProjectCMakeModules $Platform ASN1);
|
|
SwiftCertificates_DIR = (Get-ProjectCMakeModules $Platform Certificates);
|
|
SwiftSyntax_DIR = (Get-ProjectCMakeModules $Platform Compilers);
|
|
SQLite3_INCLUDE_DIR = "$LibraryRoot\sqlite-3.46.0\usr\include";
|
|
SQLite3_LIBRARY = "$LibraryRoot\sqlite-3.46.0\usr\lib\SQLite3.lib";
|
|
}
|
|
}
|
|
|
|
function Build-Markdown([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-markdown `
|
|
-Bin (Get-ProjectBinaryCache $Platform Markdown) `
|
|
-InstallTo "$($Platform.ToolchainInstallRoot)\usr" `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers C,Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "NO";
|
|
CMAKE_STATIC_LIBRARY_PREFIX_Swift = "lib";
|
|
ArgumentParser_DIR = (Get-ProjectCMakeModules $Platform ArgumentParser);
|
|
"cmark-gfm_DIR" = "$($Platform.ToolchainInstallRoot)\usr\lib\cmake";
|
|
}
|
|
}
|
|
|
|
function Build-Format([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-format `
|
|
-Bin (Get-ProjectBinaryCache $Platform Format) `
|
|
-InstallTo "$($Platform.ToolchainInstallRoot)\usr" `
|
|
-Platform $Platform `
|
|
-UseMSVCCompilers C `
|
|
-UseBuiltCompilers Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "YES";
|
|
ArgumentParser_DIR = (Get-ProjectCMakeModules $Platform ArgumentParser);
|
|
SwiftSyntax_DIR = (Get-ProjectCMakeModules $Platform Compilers);
|
|
SwiftMarkdown_DIR = (Get-ProjectCMakeModules $Platform Markdown);
|
|
"cmark-gfm_DIR" = "$($Platform.ToolchainInstallRoot)\usr\lib\cmake";
|
|
}
|
|
}
|
|
|
|
function Test-Format {
|
|
$SwiftPMArguments = @(
|
|
# swift-syntax
|
|
"-Xswiftc", "-I$(Get-ProjectBinaryCache $BuildPlatform Compilers)\lib\swift\host",
|
|
"-Xswiftc", "-L$(Get-ProjectBinaryCache $BuildPlatform Compilers)\lib\swift\host",
|
|
# swift-argument-parser
|
|
"-Xswiftc", "-I$(Get-ProjectBinaryCache $BuildPlatform ArgumentParser)\swift",
|
|
"-Xlinker", "-L$(Get-ProjectBinaryCache $BuildPlatform ArgumentParser)\lib",
|
|
# swift-cmark
|
|
"-Xswiftc", "-I$SourceCache\cmark\src\include",
|
|
"-Xswiftc", "-I$SourceCache\cmark\extensions\include",
|
|
"-Xlinker", "-I$SourceCache\cmark\extensions\include",
|
|
"-Xlinker", "$(Get-CMarkBinaryCache $HostPlatform)\src\cmark-gfm.lib",
|
|
"-Xlinker", "$(Get-CMarkBinaryCache $HostPlatform)\extensions\cmark-gfm-extensions.lib",
|
|
# swift-markdown
|
|
"-Xlinker", "$(Get-ProjectBinaryCache $BuildPlatform Markdown)\lib\CAtomic.lib",
|
|
"-Xswiftc", "-I$SourceCache\swift-markdown\Sources\CAtomic\include",
|
|
"-Xswiftc", "-I$(Get-ProjectBinaryCache $BuildPlatform Markdown)\swift",
|
|
"-Xlinker", "-L$(Get-ProjectBinaryCache $BuildPlatform Markdown)\lib",
|
|
# swift-format
|
|
"-Xswiftc", "-I$(Get-ProjectBinaryCache $BuildPlatform Format)\swift",
|
|
"-Xlinker", "-L$(Get-ProjectBinaryCache $BuildPlatform Format)\lib"
|
|
)
|
|
|
|
Invoke-IsolatingEnvVars {
|
|
$env:SWIFTFORMAT_BUILD_ONLY_TESTS=1
|
|
# Testing swift-format is faster in serial mode than in parallel mode, probably because parallel test execution
|
|
# launches a process for every test class and the process launching overhead on Windows is greater than any
|
|
# gains from parallel test execution.
|
|
Build-SPMProject `
|
|
-Action Test `
|
|
-Src "$SourceCache\swift-format" `
|
|
-Bin "$BinaryCache\$($HostPlatform.Triple)\FormatTests" `
|
|
-Platform $BuildPlatform `
|
|
@SwiftPMArguments
|
|
}
|
|
}
|
|
|
|
function Build-LMDB([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-lmdb `
|
|
-Bin (Get-ProjectBinaryCache $Platform LMDB) `
|
|
-Platform $Platform `
|
|
-UseMSVCCompilers C `
|
|
-BuildTargets default
|
|
}
|
|
|
|
function Build-IndexStoreDB([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\indexstore-db `
|
|
-Bin (Get-ProjectBinaryCache $Platform IndexStoreDB) `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers C,CXX,Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-BuildTargets default `
|
|
-Defines @{
|
|
BUILD_SHARED_LIBS = "NO";
|
|
CMAKE_STATIC_LIBRARY_PREFIX_Swift = "lib";
|
|
CMAKE_C_FLAGS = @("-I$(Get-SwiftSDK Windows)\usr\include", "-I$(Get-SwiftSDK Windows)\usr\include\Block");
|
|
CMAKE_CXX_FLAGS = @("-I$(Get-SwiftSDK Windows)\usr\include", "-I$(Get-SwiftSDK Windows)\usr\include\Block");
|
|
LMDB_DIR = (Get-ProjectCMakeModules $Platform LMDB);
|
|
}
|
|
}
|
|
|
|
function Build-SourceKitLSP([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\sourcekit-lsp `
|
|
-Bin (Get-ProjectBinaryCache $Platform SourceKitLSP) `
|
|
-InstallTo "$($Platform.ToolchainInstallRoot)\usr" `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers C,Swift `
|
|
-SwiftSDK (Get-SwiftSDK Windows) `
|
|
-Defines @{
|
|
CMAKE_STATIC_LIBRARY_PREFIX_Swift = "lib";
|
|
SwiftSyntax_DIR = (Get-ProjectCMakeModules $Platform Compilers);
|
|
TSC_DIR = (Get-ProjectCMakeModules $Platform ToolsSupportCore);
|
|
LLBuild_DIR = (Get-ProjectCMakeModules $Platform LLBuild);
|
|
ArgumentParser_DIR = (Get-ProjectCMakeModules $Platform ArgumentParser);
|
|
SwiftCrypto_DIR = (Get-ProjectCMakeModules $Platform Crypto);
|
|
SwiftCollections_DIR = (Get-ProjectCMakeModules $Platform Collections);
|
|
SwiftPM_DIR = (Get-ProjectCMakeModules $Platform PackageManager);
|
|
LMDB_DIR = (Get-ProjectCMakeModules $Platform LMDB);
|
|
IndexStoreDB_DIR = (Get-ProjectCMakeModules $Platform IndexStoreDB);
|
|
}
|
|
}
|
|
|
|
function Test-SourceKitLSP {
|
|
$SwiftPMArguments = @(
|
|
# dispatch
|
|
"-Xcc", "-I$SourceCache\swift-corelibs-libdispatch",
|
|
"-Xcc", "-I$SourceCache\swift-corelibs-libdispatch\src\BlocksRuntime",
|
|
# swift-syntax
|
|
"-Xswiftc", "-I$(Get-ProjectBinaryCache $BuildPlatform Compilers)\lib\swift\host",
|
|
"-Xswiftc", "-L$(Get-ProjectBinaryCache $BuildPlatform Compilers)\lib\swift\host",
|
|
# swift-cmark
|
|
"-Xswiftc", "-I$SourceCache\cmark\src\include",
|
|
"-Xswiftc", "-I$SourceCache\cmark\extensions\include",
|
|
"-Xlinker", "-I$SourceCache\cmark\extensions\include",
|
|
"-Xlinker", "$(Get-CMarkBinaryCache $HostPlatform)\src\cmark-gfm.lib",
|
|
"-Xlinker", "$(Get-CMarkBinaryCache $HostPlatform)\extensions\cmark-gfm-extensions.lib",
|
|
# swift-system
|
|
"-Xswiftc", "-I$SourceCache\swift-system\Sources\CSystem\include",
|
|
"-Xswiftc", "-I$(Get-ProjectBinaryCache $BuildPlatform System)\swift",
|
|
"-Xlinker", "-L$(Get-ProjectBinaryCache $BuildPlatform System)\lib",
|
|
# swift-tools-support-core
|
|
"-Xswiftc", "-I$(Get-ProjectBinaryCache $BuildPlatform ToolsSupportCore)\swift",
|
|
"-Xlinker", "-L$(Get-ProjectBinaryCache $BuildPlatform ToolsSupportCore)\lib",
|
|
# swift-llbuild
|
|
"-Xswiftc", "-I$SourceCache\llbuild\products\libllbuild\include",
|
|
"-Xswiftc", "-I$(Get-ProjectBinaryCache $BuildPlatform LLBuild)\products\llbuildSwift",
|
|
"-Xlinker", "-L$(Get-ProjectBinaryCache $BuildPlatform LLBuild)\lib",
|
|
# swift-argument-parser
|
|
"-Xswiftc", "-I$(Get-ProjectBinaryCache $BuildPlatform ArgumentParser)\swift",
|
|
"-Xlinker", "-L$(Get-ProjectBinaryCache $BuildPlatform ArgumentParser)\lib",
|
|
# swift-crypto
|
|
"-Xswiftc", "-I$(Get-ProjectBinaryCache $BuildPlatform Crypto)\swift",
|
|
"-Xlinker", "-L$(Get-ProjectBinaryCache $BuildPlatform Crypto)\lib",
|
|
"-Xlinker", "$(Get-ProjectBinaryCache $BuildPlatform Crypto)\lib\CCryptoBoringSSL.lib",
|
|
# swift-package-manager
|
|
"-Xswiftc", "-I$(Get-ProjectBinaryCache $BuildPlatform PackageManager)\swift",
|
|
"-Xlinker", "-L$(Get-ProjectBinaryCache $BuildPlatform PackageManager)\lib",
|
|
# swift-markdown
|
|
"-Xswiftc", "-I$SourceCache\swift-markdown\Sources\CAtomic\inclde",
|
|
"-Xlinker", "$(Get-ProjectBinaryCache $BuildPlatform Markdown)\lib\CAtomic.lib",
|
|
"-Xswiftc", "-I$(Get-ProjectBinaryCache $BuildPlatform Markdown)\swift",
|
|
"-Xlinker", "-L$(Get-ProjectBinaryCache $BuildPlatform Markdown)\lib",
|
|
# swift-format
|
|
"-Xswiftc", "-I$(Get-ProjectBinaryCache $BuildPlatform Format)\swift",
|
|
"-Xlinker", "-L$(Get-ProjectBinaryCache $BuildPlatform Format)\lib",
|
|
# indexstore-db
|
|
"-Xswiftc", "-I$(Get-ProjectBinaryCache $BuildPlatform IndexStoreDB)\swift",
|
|
"-Xlinker", "-L$(Get-ProjectBinaryCache $BuildPlatform IndexStoreDB)\Sources\IndexStoreDB",
|
|
"-Xlinker", "$(Get-ProjectBinaryCache $BuildPlatform IndexStoreDB)\Sources\IndexStoreDB_CIndexStoreDB\CIndexStoreDB.lib",
|
|
"-Xlinker", "$(Get-ProjectBinaryCache $BuildPlatform IndexStoreDB)\Sources\IndexStoreDB_Core\Core.lib",
|
|
"-Xlinker", "$(Get-ProjectBinaryCache $BuildPlatform IndexStoreDB)\Sources\IndexStoreDB_Database\Database.lib",
|
|
"-Xlinker", "$(Get-ProjectBinaryCache $BuildPlatform IndexStoreDB)\Sources\IndexStoreDB_Index\Index.lib",
|
|
"-Xlinker", "$(Get-ProjectBinaryCache $BuildPlatform IndexStoreDB)\Sources\IndexStoreDB_LLVMSupport\LLVMSupport.lib",
|
|
"-Xlinker", "$(Get-ProjectBinaryCache $BuildPlatform IndexStoreDB)\Sources\IndexStoreDB_Support\Support.lib",
|
|
# LMDB
|
|
"-Xlinker", "$(Get-ProjectBinaryCache $BuildPlatform LMDB)\lib\CLMDB.lib",
|
|
# sourcekit-lsp
|
|
"-Xswiftc", "-I$SourceCache\sourcekit-lsp\Sources\CAtomics\include",
|
|
"-Xswiftc", "-I$SourceCache\sourcekit-lsp\Sources\CSourcekitd\include",
|
|
"-Xlinker", "$(Get-ProjectBinaryCache $BuildPlatform SourceKitLSP)\lib\CSourcekitd.lib",
|
|
"-Xswiftc", "-I$SourceCache\sourcekit-lsp\Sources\CCompletionScoring\include",
|
|
"-Xswiftc", "-I$(Get-ProjectBinaryCache $BuildPlatform SourceKitLSP)\swift",
|
|
"-Xlinker", "-L$(Get-ProjectBinaryCache $BuildPlatform SourceKitLSP)\lib"
|
|
)
|
|
|
|
Invoke-IsolatingEnvVars {
|
|
$env:SOURCEKIT_LSP_BUILD_ONLY_TESTS=1
|
|
|
|
# CI doesn't contain any sensitive information. Log everything.
|
|
$env:SOURCEKIT_LSP_LOG_PRIVACY_LEVEL="sensitive"
|
|
|
|
# Log with the highest log level to simplify debugging of CI failures.
|
|
$env:SOURCEKIT_LSP_LOG_LEVEL="debug"
|
|
|
|
# The Windows build doesn't build the SourceKit plugins into the SwiftPM build directory (it builds them using CMake).
|
|
# Tell the tests where to find the just-built plugins.
|
|
$env:SOURCEKIT_LSP_TEST_PLUGIN_PATHS="$($HostPlatform.ToolchainInstallRoot)\usr\lib"
|
|
|
|
Build-SPMProject `
|
|
-Action TestParallel `
|
|
-Src "$SourceCache\sourcekit-lsp" `
|
|
-Bin "$BinaryCache\$($HostPlatform.Triple)\SourceKitLSPTests" `
|
|
-Platform $BuildPlatform `
|
|
@SwiftPMArguments
|
|
}
|
|
}
|
|
|
|
function Build-TestingMacros([Hashtable] $Platform) {
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift-testing\Sources\TestingMacros `
|
|
-Bin (Get-ProjectBinaryCache $Platform TestingMacros) `
|
|
-InstallTo "$($Platform.ToolchainInstallRoot)\usr" `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers Swift `
|
|
-SwiftSDK (Get-SwiftSDK $Platform.OS) `
|
|
-Defines @{
|
|
SwiftSyntax_DIR = (Get-ProjectCMakeModules $Platform Compilers);
|
|
}
|
|
}
|
|
|
|
function Install-HostToolchain() {
|
|
if ($ToBatch) { return }
|
|
|
|
# We've already special-cased $HostPlatform.ToolchainInstallRoot to point to $ToolchainInstallRoot.
|
|
# There are only a few extra restructuring steps we need to take care of.
|
|
|
|
# Restructure _InternalSwiftScan (keep the original one for the installer)
|
|
Copy-Item -Force `
|
|
"$($HostPlatform.ToolchainInstallRoot)\usr\lib\swift\_InternalSwiftScan" `
|
|
"$($HostPlatform.ToolchainInstallRoot)\usr\include"
|
|
Copy-Item -Force `
|
|
"$($HostPlatform.ToolchainInstallRoot)\usr\lib\swift\windows\_InternalSwiftScan.lib" `
|
|
"$($HostPlatform.ToolchainInstallRoot)\usr\lib"
|
|
|
|
# Switch to swift-driver
|
|
$SwiftDriver = ([IO.Path]::Combine((Get-ProjectBinaryCache $HostPlatform Driver), "bin", "swift-driver.exe"))
|
|
Copy-Item -Force $SwiftDriver "$($HostPlatform.ToolchainInstallRoot)\usr\bin\swift.exe"
|
|
Copy-Item -Force $SwiftDriver "$($HostPlatform.ToolchainInstallRoot)\usr\bin\swiftc.exe"
|
|
}
|
|
|
|
function Build-Inspect([Hashtable] $Platform) {
|
|
if ($Platform -eq $HostPlatform) {
|
|
# When building for the host target, use the host version of the swift-argument-parser,
|
|
# and place the host swift-inspect executable with the other host toolchain binaries.
|
|
$ArgumentParserDir = Get-ProjectCMakeModules $HostPlatform ArgumentParser
|
|
$InstallPath = "$($HostPlatform.ToolchainInstallRoot)\usr"
|
|
} else {
|
|
# When building for non-host target, let CMake fetch the swift-argument-parser dependency
|
|
# since it is currently only built for the host and and cannot be built for Android until
|
|
# the pinned version is >= 1.5.0.
|
|
$ArgumentParserDir = ""
|
|
$InstallPath = "$(Get-PlatformRoot $Platform.OS)\Developer\Library\$(Get-ModuleTriple $Platform)"
|
|
}
|
|
|
|
Build-CMakeProject `
|
|
-Src $SourceCache\swift\tools\swift-inspect `
|
|
-Bin (Get-ProjectBinaryCache $Platform SwiftInspect)`
|
|
-InstallTo $InstallPath `
|
|
-Platform $Platform `
|
|
-UseBuiltCompilers C,CXX,Swift `
|
|
-SwiftSDK (Get-SwiftSDK $Platform.OS) `
|
|
-Defines @{
|
|
CMAKE_Swift_FLAGS = @(
|
|
"-Xcc", "-I$(Get-SwiftSDK $Platform.OS)\usr\include",
|
|
"-Xcc", "-I$(Get-SwiftSDK $Platform.OS)\usr\lib\swift",
|
|
"-Xcc", "-I$(Get-SwiftSDK $Platform.OS)\usr\include\swift\SwiftRemoteMirror",
|
|
"-L$(Get-SwiftSDK $Platform.OS)\usr\lib\swift\$($Platform.OS.ToString())\$($Platform.Architecture.LLVMName)"
|
|
);
|
|
ArgumentParser_DIR = $ArgumentParserDir;
|
|
}
|
|
}
|
|
|
|
function Build-DocC() {
|
|
Build-SPMProject `
|
|
-Action Build `
|
|
-Src $SourceCache\swift-docc `
|
|
-Bin $(Get-ProjectBinaryCache $BuildPlatform DocC) `
|
|
-Platform $BuildPlatform `
|
|
--product docc
|
|
}
|
|
|
|
function Test-PackageManager() {
|
|
$SrcDir = if (Test-Path -Path "$SourceCache\swift-package-manager" -PathType Container) {
|
|
"$SourceCache\swift-package-manager"
|
|
} else {
|
|
"$SourceCache\swiftpm"
|
|
}
|
|
|
|
Build-SPMProject `
|
|
-Action Test `
|
|
-Src $SrcDir `
|
|
-Bin "$BinaryCache\$($HostPlatform.Triple)\PackageManagerTests" `
|
|
-Platform $HostPlatform `
|
|
-Xcc "-I$LibraryRoot\sqlite-3.46.0\usr\include" -Xlinker "-L$LibraryRoot\sqlite-3.46.0\usr\lib"
|
|
}
|
|
|
|
function Build-Installer([Hashtable] $Platform) {
|
|
# TODO(hjyamauchi) Re-enable the swift-inspect and swift-docc builds
|
|
# when cross-compiling https://github.com/apple/swift/issues/71655
|
|
$INCLUDE_SWIFT_DOCC = if ($IsCrossCompiling) { "false" } else { "true" }
|
|
|
|
$Properties = @{
|
|
BundleFlavor = "offline";
|
|
TOOLCHAIN_ROOT = "$($Platform.ToolchainInstallRoot)\";
|
|
# When cross-compiling, bundle the second mimalloc redirect dll as a workaround for
|
|
# https://github.com/microsoft/mimalloc/issues/997
|
|
WORKAROUND_MIMALLOC_ISSUE_997 = if ($IsCrossCompiling) { "true" } else { "false" };
|
|
INCLUDE_SWIFT_DOCC = $INCLUDE_SWIFT_DOCC;
|
|
SWIFT_DOCC_BUILD = "$(Get-ProjectBinaryCache $HostPlatform DocC)\release";
|
|
SWIFT_DOCC_RENDER_ARTIFACT_ROOT = "${SourceCache}\swift-docc-render-artifact";
|
|
}
|
|
|
|
Invoke-IsolatingEnvVars {
|
|
Invoke-VsDevShell $Platform
|
|
# Avoid hard-coding the VC tools version number
|
|
$VCRedistDir = (Get-ChildItem "${env:VCToolsRedistDir}\$($HostPlatform.Architecture.ShortName)" -Filter "Microsoft.VC*.CRT").FullName
|
|
if ($VCRedistDir) {
|
|
$Properties["VCRedistDir"] = "$VCRedistDir\"
|
|
}
|
|
}
|
|
|
|
foreach ($SDKPlatform in $WindowsSDKPlatforms) {
|
|
$Properties["INCLUDE_WINDOWS_$($SDKPlatform.Architecture.VSName.ToUpperInvariant())_SDK"] = "true"
|
|
$Properties["PLATFORM_ROOT_$($SDKPlatform.Architecture.VSName.ToUpperInvariant())"] = "$(Get-PlatformRoot Windows)\";
|
|
$Properties["SDK_ROOT_$($SDKPlatform.Architecture.VSName.ToUpperInvariant())"] = "$(Get-SwiftSDK Windows)\"
|
|
}
|
|
|
|
Build-WiXProject bundle\installer.wixproj -Platform $Platform -Bundle -Properties $Properties
|
|
}
|
|
|
|
function Copy-BuildArtifactsToStage([Hashtable] $Platform) {
|
|
Copy-File "$BinaryCache\$($Platform.Triple)\installer\Release\$($Platform.Architecture.VSName)\*.cab" $Stage
|
|
Copy-File "$BinaryCache\$($Platform.Triple)\installer\Release\$($Platform.Architecture.VSName)\*.msi" $Stage
|
|
foreach ($SDKPlatform in $WindowsSDKPlatforms) {
|
|
Copy-File "$BinaryCache\$($Platform.Triple)\installer\Release\$($SDKPlatform.Architecture.VSName)\sdk.windows.$($SDKPlatform.Architecture.VSName).cab" $Stage
|
|
Copy-File "$BinaryCache\$($Platform.Triple)\installer\Release\$($SDKPlatform.Architecture.VSName)\sdk.windows.$($SDKPlatform.Architecture.VSName).msi" $Stage
|
|
Copy-File "$BinaryCache\$($Platform.Triple)\installer\Release\$($SDKPlatform.Architecture.VSName)\rtl.$($SDKPlatform.Architecture.VSName).msm" $Stage
|
|
}
|
|
Copy-File "$BinaryCache\$($Platform.Triple)\installer\Release\$($Platform.Architecture.VSName)\installer.exe" $Stage
|
|
# Extract installer engine to ease code-signing on swift.org CI
|
|
if ($ToBatch) {
|
|
Write-Output "md `"$BinaryCache\$($Platform.Triple)\installer\$($Platform.Architecture.VSName)`""
|
|
} else {
|
|
New-Item -Type Directory -Path "$BinaryCache\$($Platform.Triple)\installer\$($Platform.Architecture.VSName)" -ErrorAction Ignore | Out-Null
|
|
}
|
|
Invoke-Program "$($WiX.Path)\wix.exe" -- burn detach "$BinaryCache\$($Platform.Triple)\installer\Release\$($Platform.Architecture.VSName)\installer.exe" -engine "$Stage\installer-engine.exe" -intermediateFolder "$BinaryCache\$($Platform.Triple)\installer\$($Platform.Architecture.VSName)\"
|
|
}
|
|
|
|
#-------------------------------------------------------------------
|
|
try {
|
|
|
|
Get-Dependencies
|
|
|
|
if ($Clean) {
|
|
Remove-Item -Force -Recurse -Path "$BinaryCache\$($HostPlatform.Triple)\" -ErrorAction Ignore
|
|
|
|
# In case of a previous test run, clear out the swiftmodules as they are not a stable format.
|
|
Remove-Item -Force -Recurse -Path "$($HostPlatform.ToolchainInstallRoot)\usr\lib\swift\windows\*.swiftmodule" -ErrorAction Ignore
|
|
foreach ($Platform in $WindowsSDKPlatforms) {
|
|
Remove-Item -Force -Recurse -Path "$BinaryCache\$($Platform.Triple)\" -ErrorAction Ignore
|
|
}
|
|
foreach ($Platform in $AndroidSDKPlatforms) {
|
|
Remove-Item -Force -Recurse -Path "$BinaryCache\$($Platform.Triple)\" -ErrorAction Ignore
|
|
}
|
|
|
|
Remove-Item -Force -Recurse ([IO.Path]::Combine((Get-InstallDir $HostPlatform), "Runtimes", $ProductVersion)) -ErrorAction Ignore
|
|
}
|
|
|
|
if (-not $SkipBuild) {
|
|
if ($EnableCaching -And (-Not (Test-SCCacheAtLeast -Major 0 -Minor 7 -Patch 4))) {
|
|
throw "Minimum required sccache version is 0.7.4"
|
|
}
|
|
|
|
Remove-Item -Force -Recurse ([IO.Path]::Combine((Get-InstallDir $HostPlatform), "Platforms")) -ErrorAction Ignore
|
|
|
|
Invoke-BuildStep Build-CMark $BuildPlatform
|
|
Invoke-BuildStep Build-BuildTools $BuildPlatform
|
|
if ($IsCrossCompiling) {
|
|
Invoke-BuildStep Build-XML2 $BuildPlatform
|
|
Invoke-BuildStep Build-Compilers $BuildPlatform
|
|
}
|
|
if ($IncludeDS2) {
|
|
Invoke-BuildStep Build-RegsGen2 $BuildPlatform
|
|
}
|
|
|
|
Invoke-BuildStep Build-CMark $HostPlatform
|
|
Invoke-BuildStep Build-XML2 $HostPlatform
|
|
Invoke-BuildStep Build-Compilers $HostPlatform
|
|
|
|
foreach ($Platform in $WindowsSDKPlatforms) {
|
|
Invoke-BuildStep Build-ZLib $Platform
|
|
Invoke-BuildStep Build-XML2 $Platform
|
|
Invoke-BuildStep Build-CURL $Platform
|
|
Invoke-BuildStep Build-LLVM $Platform
|
|
|
|
# Build platform: SDK, Redist and XCTest
|
|
Invoke-BuildStep Build-Runtime $Platform
|
|
Invoke-BuildStep Build-Dispatch $Platform
|
|
# FIXME(compnerd) ensure that the _build_ is the first arch and don't rebuild on each arch
|
|
if ($Platform -eq $BuildPlatform) {
|
|
Invoke-BuildStep Build-FoundationMacros $BuildPlatform
|
|
Invoke-BuildStep Build-TestingMacros $BuildPlatform
|
|
}
|
|
Invoke-BuildStep Build-Foundation $Platform
|
|
Invoke-BuildStep Build-Sanitizers $Platform
|
|
Invoke-BuildStep Build-XCTest $Platform
|
|
Invoke-BuildStep Build-Testing $Platform
|
|
Invoke-BuildStep Write-SDKSettingsPlist $Platform
|
|
|
|
Invoke-BuildStep Build-ExperimentalRuntime $Platform -Static
|
|
Invoke-BuildStep Build-Foundation $Platform -Static
|
|
|
|
Copy-File "$(Get-SwiftSDK Windows)\usr\lib\swift\windows\*.lib" "$(Get-SwiftSDK Windows)\usr\lib\swift\windows\$($Platform.Architecture.LLVMName)\"
|
|
if ($Platform -eq $HostPlatform) {
|
|
Copy-Directory "$(Get-SwiftSDK Windows)\usr\bin" "$([IO.Path]::Combine((Get-InstallDir $HostPlatform), "Runtimes", $ProductVersion))\usr"
|
|
}
|
|
}
|
|
Install-Platform $WindowsSDKPlatforms Windows
|
|
Invoke-BuildStep Write-PlatformInfoPlist $HostPlatform
|
|
|
|
if ($Android) {
|
|
foreach ($Platform in $AndroidSDKPlatforms) {
|
|
if ($IncludeDS2) {
|
|
Invoke-BuildStep Build-DS2 $Platform
|
|
}
|
|
Invoke-BuildStep Build-ZLib $Platform
|
|
Invoke-BuildStep Build-XML2 $Platform
|
|
Invoke-BuildStep Build-CURL $Platform
|
|
Invoke-BuildStep Build-LLVM $Platform
|
|
|
|
# Build platform: SDK, Redist and XCTest
|
|
Invoke-BuildStep Build-Runtime $Platform
|
|
Invoke-BuildStep Build-Dispatch $Platform
|
|
Invoke-BuildStep Build-Foundation $Platform
|
|
Invoke-BuildStep Build-Sanitizers $Platform
|
|
Invoke-BuildStep Build-XCTest $Platform
|
|
Invoke-BuildStep Build-Testing $Platform
|
|
|
|
# Android swift-inspect only supports 64-bit platforms.
|
|
if ($Platform.Architecture.ABI -in @("arm64-v8a", "x86_64")) {
|
|
Invoke-BuildStep Build-Inspect $Platform
|
|
}
|
|
Invoke-BuildStep Write-SDKSettingsPlist $Platform
|
|
|
|
Invoke-BuildStep Build-ExperimentalRuntime $Platform -Static
|
|
Invoke-BuildStep Build-Foundation $Platform -Static
|
|
|
|
Move-Item "$(Get-SwiftSDK Android)\usr\lib\swift\android\*.a" "$(Get-SwiftSDK Android)\usr\lib\swift\android\$($Platform.Architecture.LLVMName)\"
|
|
Move-Item "$(Get-SwiftSDK Android)\usr\lib\swift\android\*.so" "$(Get-SwiftSDK Android)\usr\lib\swift\android\$($Platform.Architecture.LLVMName)\"
|
|
}
|
|
Install-Platform $AndroidSDKPlatforms Android
|
|
Invoke-BuildStep Write-PlatformInfoPlist $Platform
|
|
}
|
|
|
|
# Build Macros for distribution
|
|
Invoke-BuildStep Build-FoundationMacros $HostPlatform
|
|
Invoke-BuildStep Build-TestingMacros $HostPlatform
|
|
|
|
Invoke-BuildStep Build-SQLite $HostPlatform
|
|
Invoke-BuildStep Build-ToolsSupportCore $HostPlatform
|
|
Invoke-BuildStep Build-LLBuild $HostPlatform
|
|
Invoke-BuildStep Build-ArgumentParser $HostPlatform
|
|
Invoke-BuildStep Build-Driver $HostPlatform
|
|
Invoke-BuildStep Build-Crypto $HostPlatform
|
|
Invoke-BuildStep Build-Collections $HostPlatform
|
|
Invoke-BuildStep Build-ASN1 $HostPlatform
|
|
Invoke-BuildStep Build-Certificates $HostPlatform
|
|
Invoke-BuildStep Build-System $HostPlatform
|
|
Invoke-BuildStep Build-Build $HostPlatform
|
|
Invoke-BuildStep Build-PackageManager $HostPlatform
|
|
Invoke-BuildStep Build-Markdown $HostPlatform
|
|
Invoke-BuildStep Build-Format $HostPlatform
|
|
Invoke-BuildStep Build-LMDB $HostPlatform
|
|
Invoke-BuildStep Build-IndexStoreDB $HostPlatform
|
|
Invoke-BuildStep Build-SourceKitLSP $HostPlatform
|
|
Invoke-BuildStep Build-Inspect $HostPlatform
|
|
}
|
|
|
|
Install-HostToolchain
|
|
|
|
if (-not $SkipBuild) {
|
|
Invoke-BuildStep Build-mimalloc $HostPlatform
|
|
}
|
|
|
|
if (-not $SkipBuild -and -not $IsCrossCompiling) {
|
|
Invoke-BuildStep Build-DocC $HostPlatform
|
|
}
|
|
|
|
if (-not $SkipPackaging) {
|
|
Invoke-BuildStep Build-Installer $HostPlatform
|
|
}
|
|
|
|
if ($Stage) {
|
|
Copy-BuildArtifactsToStage $HostPlatform
|
|
}
|
|
|
|
if (-not $IsCrossCompiling) {
|
|
$CompilersTests = @("clang", "lld", "lldb", "llvm", "swift")
|
|
if ($Test | Where-Object { $CompilersTests -contains $_ }) {
|
|
$Tests = @{
|
|
"-TestClang" = $Test -contains "clang";
|
|
"-TestLLD" = $Test -contains "lld";
|
|
"-TestLLDB" = $Test -contains "lldb";
|
|
"-TestLLVM" = $Test -contains "llvm";
|
|
"-TestSwift" = $Test -contains "swift";
|
|
}
|
|
Invoke-BuildStep Test-Compilers $HostPlatform $Tests
|
|
}
|
|
|
|
# FIXME(jeffdav): Invoke-BuildStep needs a platform dictionary, even though the Test-
|
|
# functions hardcode their platform needs.
|
|
if ($Test -contains "dispatch") { Invoke-BuildStep Test-Dispatch $BuildPlatform }
|
|
if ($Test -contains "foundation") { Invoke-BuildStep Test-Foundation $BuildPlatform }
|
|
if ($Test -contains "xctest") { Invoke-BuildStep Test-XCTest $BuildPlatform }
|
|
if ($Test -contains "testing") { Invoke-BuildStep Test-Testing $BuildPlatform }
|
|
if ($Test -contains "llbuild") { Invoke-BuildStep Test-LLBuild $BuildPlatform }
|
|
if ($Test -contains "swiftpm") { Invoke-BuildStep Test-PackageManager $BuildPlatform }
|
|
if ($Test -contains "swift-format") { Invoke-BuildStep Test-Format $BuildPlatform }
|
|
if ($Test -contains "sourcekit-lsp") { Invoke-BuildStep Test-SourceKitLSP $BuildPlatform}
|
|
|
|
if ($Test -contains "swift") {
|
|
foreach ($Platform in $AndroidSDKPlatforms) {
|
|
try {
|
|
Invoke-BuildStep Test-Runtime $Platform
|
|
} catch {}
|
|
}
|
|
}
|
|
}
|
|
|
|
# Custom exception printing for more detailed exception information
|
|
} catch {
|
|
function Write-ErrorLines($Text, $Indent = 0) {
|
|
$IndentString = " " * $Indent
|
|
$Text.Replace("`r", "") -split "`n" | ForEach-Object {
|
|
Write-Host "$IndentString$_" -ForegroundColor Red
|
|
}
|
|
}
|
|
|
|
Write-ErrorLines "Error: $_"
|
|
Write-ErrorLines $_.ScriptStackTrace -Indent 4
|
|
|
|
# Walk the .NET inner exception chain to print all messages and stack traces
|
|
$Exception = $_.Exception
|
|
$Indent = 2
|
|
while ($Exception -is [Exception]) {
|
|
Write-ErrorLines "From $($Exception.GetType().FullName): $($Exception.Message)" -Indent $Indent
|
|
if ($null -ne $Exception.StackTrace) {
|
|
# .NET exceptions stack traces are already indented by 3 spaces
|
|
Write-ErrorLines $Exception.StackTrace -Indent ($Indent + 1)
|
|
}
|
|
$Exception = $Exception.InnerException
|
|
$Indent += 2
|
|
}
|
|
|
|
exit 1
|
|
} finally {
|
|
if ($Summary) {
|
|
Write-Summary
|
|
}
|
|
}
|