build.ps1

# 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

.PARAMETERSourceCache
The path to a directory where projects contributing to the Swift.
toolchain have been cloned.

.PARAMETERBinaryCache
The path to a directory where to write build system files and outputs.

.PARAMETERImageRoot
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.

.PARAMETERCDebugFormat
The debug information format for C/C++ code: dwarf or codeview.

.PARAMETERSwiftDebugFormat
The debug information format for Swift code: dwarf or codeview.

.PARAMETERSDKs
An array of architectures for which the Swift SDK should be built.

.PARAMETERProductVersion
The product version to be used when building the installer.
Supports semantic version strings.

.PARAMETERPinnedBuild
The toolchain snapshot to build the early components with.

.PARAMETERPinnedSHA256
The SHA256 for the pinned toolchain.

.PARAMETERWinSDKVersion
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.

.PARAMETERSkipBuild
If set, does not run the build phase.

.PARAMETERSkipPackaging
If set, skips building the msi's and installer

.PARAMETERDefaultsLLD
If false, use `link.exe` as the default linker with the SDK (with SPM)

.PARAMETERDebugInfo
If set, debug information will be generated for the builds.

.PARAMETEREnableCaching
If true, use `sccache` to cache the build rules.

.PARAMETERTest
An array of names of projects to run tests for.
'*' runs all tests

.PARAMETERStage
The path to a directory where built msi's and the installer executable should be staged (for CI).

.PARAMETERBuildTo
The name of a build step after which the script should terminate.
For example: -BuildTo ToolsSupportCore

.PARAMETERToBatch
When set, runs the script in a special mode which outputs a listing of command invocations
in batch file format instead of executing them.

.EXAMPLE
PS> .\Build.ps1

.EXAMPLE
PS> .\Build.ps1 -SDKs x64 -ProductVersion 1.2.3 -Test foundation,xctest
#>
[CmdletBinding(PositionalBinding=$false)]
param(
 [string] $SourceCache="S:\SourceCache",
 [string] $BinaryCache="S:\b",
 [string] $ImageRoot="S:",
 [string] $CDebugFormat="dwarf",
 [string] $SwiftDebugFormat="dwarf",
 [string[]] $SDKs=@("X64","X86","Arm64"),
 [string] $ProductVersion="0.0.0",
 [string] $PinnedBuild="https://download.swift.org/swift-5.9-release/windows10/swift-5.9-RELEASE/swift-5.9-RELEASE-windows10.exe",
 [string] $PinnedSHA256="EAB668ABFF903B4B8111FD27F49BAD470044B6403C6FA9CCD357AE831909856D",
 [string] $WinSDKVersion="",
 [switch] $SkipBuild=$false,
 [switch] $SkipRedistInstall=$false,
 [switch] $SkipPackaging=$false,
 [bool] $DefaultsLLD=$true,
 [string[]] $Test=@(),
 [string] $Stage="",
 [string] $BuildTo="",
 [switch] $DebugInfo,
 [switch] $EnableCaching,
 [switch] $ToBatch
)

$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 ($null-ne$env:VSCMD_ARG_HOST_ARCH-or$null-ne$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=""
$NativeProcessorArchName=$env:PROCESSOR_ARCHITEW6432
if ($null-eq$NativeProcessorArchName) { $NativeProcessorArchName=$env:PROCESSOR_ARCHITECTURE }

# Store the revision zero variant of the Windows SDK version (no-op if unspecified)
$WindowsSDKMajorMinorBuildMatch= [Regex]::Match($WinSDKVersion,"^\d+\.\d+\.\d+")
$WinSDKVersionRevisionZero=if ($WindowsSDKMajorMinorBuildMatch.Success) { $WindowsSDKMajorMinorBuildMatch.Value+".0" } else { "" }
$CustomWinSDKRoot=$null# Overwritten if we download a Windows SDK from nuget

$vswhere="${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe"
$VSInstallRoot=&$vswhere-nologo -latest -products "*"-all -prerelease -property installationPath
$msbuild="$VSInstallRoot\MSBuild\Current\Bin\$NativeProcessorArchName\MSBuild.exe"

# Avoid $env:ProgramFiles in case this script is running as x86
$UnixToolsBinDir="$env:SystemDrive\Program Files\Git\usr\bin"

$python="${env:ProgramFiles(x86)}\Microsoft Visual Studio\Shared\Python39_64\python.exe"
if (-not (Test-Path$python)) {
$python= (where.exe python) |Select-Object-First 1
if (-not (Test-Path$python)) {
throw"Python.exe not found"
 }
}

# Work around limitations of cmd passing in array arguments via powershell.exe -File
if ($SDKs.Length-eq1) { $SDKs=$SDKs[0].Split(",") }
if ($Test.Length-eq1) { $Test=$Test[0].Split(",") }

if ($Test-contains"*") {
# Explicitly don't include llbuild yet since tests are known to fail on Windows
$Test=@("swift","dispatch","foundation","xctest")
}

# Architecture definitions
$ArchX64=@{
VSName="amd64";
ShortName="x64";
LLVMName="x86_64";
LLVMTarget="x86_64-unknown-windows-msvc";
CMakeName="AMD64";
BinaryDir="bin64";
BuildID=100;
BinaryCache="$BinaryCache\x64";
PlatformInstallRoot="$BinaryCache\x64\Windows.platform";
SDKInstallRoot="$BinaryCache\x64\Windows.platform\Developer\SDKs\Windows.sdk";
XCTestInstallRoot="$BinaryCache\x64\Windows.platform\Developer\Library\XCTest-development";
ToolchainInstallRoot="$BinaryCache\x64\toolchains\$ProductVersion+Asserts";
}

$ArchX86=@{
VSName="x86";
ShortName="x86";
LLVMName="i686";
LLVMTarget="i686-unknown-windows-msvc";
CMakeName="i686";
BinaryDir="bin32";
BuildID=200;
BinaryCache="$BinaryCache\x86";
PlatformInstallRoot="$BinaryCache\x86\Windows.platform";
SDKInstallRoot="$BinaryCache\x86\Windows.platform\Developer\SDKs\Windows.sdk";
XCTestInstallRoot="$BinaryCache\x86\Windows.platform\Developer\Library\XCTest-development";
}

$ArchARM64=@{
VSName="arm64";
ShortName="arm64";
LLVMName="aarch64";
LLVMTarget="aarch64-unknown-windows-msvc";
CMakeName="aarch64";
BinaryDir="bin64a";
BuildID=300;
BinaryCache="$BinaryCache\arm64";
PlatformInstallRoot="$BinaryCache\arm64\Windows.platform";
SDKInstallRoot="$BinaryCache\arm64\Windows.platform\Developer\SDKs\Windows.sdk";
XCTestInstallRoot="$BinaryCache\arm64\Windows.platform\Developer\Library\XCTest-development";
ToolchainInstallRoot="$BinaryCache\arm64\toolchains\$ProductVersion+Asserts";
}

$HostArch=switch ($NativeProcessorArchName) {
"AMD64" { $ArchX64 }
"ARM64" { $ArchARM64 }
default { throw"Unsupported processor architecture" }
}

functionGet-InstallDir($Arch) {
if ($Arch-eq$HostArch) {
$ProgramFilesName="Program Files"
 } elseif ($Arch-eq$ArchX86) {
$ProgramFilesName="Program Files (x86)"
 } elseif (($HostArch-eq$ArchArm64) -and ($Arch-eq$ArchX64)) {
# 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"
}

$NugetRoot="$BinaryCache\nuget"
$PinnedToolchain= [IO.Path]::GetFileNameWithoutExtension($PinnedBuild)

$LibraryRoot="$ImageRoot\Library"
$ToolchainInstallRoot="$(Get-InstallDir$HostArch)\Toolchains\$ProductVersion+Asserts"
$PlatformInstallRoot="$(Get-InstallDir$HostArch)\Platforms\Windows.platform"
$RuntimeInstallRoot="$(Get-InstallDir$HostArch)\Runtimes\$ProductVersion"
$SDKInstallRoot="$PlatformInstallRoot\Developer\SDKs\Windows.sdk"

# For dev productivity, install the host toolchain directly using CMake.
# This allows iterating on the toolchain using ninja builds.
$HostArch.ToolchainInstallRoot=$ToolchainInstallRoot

# Resolve the architectures received as argument
$SDKArchs=@($SDKs|ForEach-Object {
switch ($_) {
"X64" { $ArchX64 }
"X86" { $ArchX86 }
"Arm64" { $ArchArm64 }
default { throw"Unknown architecture $_" }
 }
})

# Build functions
functionInvoke-BuildStep([string]$Name) {
&$Name@Args
if ($Name.Replace("Build-","") -eq$BuildTo) {
exit0
 }
}

functionGet-ProjectBinaryCache($Arch,$ID) {
return"$BinaryCache\"+ ($Arch.BuildID+$ID)
}

functionCopy-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
 }
}

functionCopy-Directory($Src,$Dst) {
New-Item-ItemType Directory -ErrorAction Ignore $Dst|Out-Null
Copy-Item-Force -Recurse $Src$Dst
}

functionInvoke-Program() {
 [CmdletBinding(PositionalBinding=$false)]
param(
 [Parameter(Position=0,Mandatory=$true)]
 [string] $Executable,
 [switch] $OutNull=$false,
 [string] $OutFile="",
 [Parameter(Position=1,ValueFromRemainingArguments)]
 [string[]] $Args
 )

if ($ToBatch) {
# Print the invocation in batch file-compatible format
$OutputLine="`"$Executable`""
$ShouldBreakLine=$false
for ($i=0; $i-lt$Args.Length; $i++) {
if ($ShouldBreakLine-or$OutputLine.Length-ge40) {
$OutputLine+=" ^"
Write-Output$OutputLine
$OutputLine=""
 }

$Arg=$Args[$i]
if ($Arg.Contains("")) {
$OutputLine+="`"$Arg`""
 } else {
$OutputLine+="$Arg"
 }

# Break lines after non-switch arguments
$ShouldBreakLine=-not$Arg.StartsWith("-")
 }

if ($OutNull) {
$OutputLine+=" > nul"
 } elseif (""-ne$OutFile) {
$OutputLine+=" > `"$OutFile`""
 }

Write-Output$OutputLine
 } else {
if ($OutNull) {
&$Executable@Args|Out-Null
 } elseif (""-ne$OutFile) {
&$Executable@Args|Out-File-Encoding UTF8 $OutFile
 } else {
&$Executable@Args
 }

if ($LastExitCode-ne0) {
$ErrorMessage="Error: $([IO.Path]::GetFileName($Executable)) exited with code $($LastExitCode).`n"

$ErrorMessage+="Invocation:`n"
$ErrorMessage+="$Executable$Args`n"

$ErrorMessage+="Call stack:`n"
foreach ($Framein@(Get-PSCallStack)) {
$ErrorMessage+="$Frame`n"
 }

throw$ErrorMessage
 }
 }
}

functionIsolate-EnvVars([scriptblock]$Block) {
if ($ToBatch) {
Write-Output"setlocal enableextensions enabledelayedexpansion"
 }

$OldVars=@{}
foreach ($Varin (Get-ChildItem env:*).GetEnumerator()) {
$OldVars.Add($Var.Key,$Var.Value)
 }

&$Block

Remove-Item env:*
foreach ($Varin$OldVars.GetEnumerator()) {
New-Item-Path "env:\$($Var.Key)"-Value $Var.Value-ErrorAction Ignore |Out-Null
 }

if ($ToBatch) {
Write-Output"endlocal"
 }
}

functionInvoke-VsDevShell($Arch) {
$DevCmdArguments="-no_logo -host_arch=$($HostArch.VSName) -arch=$($Arch.VSName)"
if ($CustomWinSDKRoot) {
$DevCmdArguments+=" -winsdk=none"
 } elseif ($WinSDKVersion) {
$DevCmdArguments+=" -winsdk=$WinSDKVersionRevisionZero"
 }

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\$WinSDKVersionRevisionZero"
$WinSDKIncludePath="$WinSDKVerIncludeRoot\ucrt;$WinSDKVerIncludeRoot\um;$WinSDKVerIncludeRoot\shared;$WinSDKVerIncludeRoot\winrt;$WinSDKVerIncludeRoot\cppwinrt"
$WinSDKVerLibRoot="$CustomWinSDKRoot\lib\$WinSDKVersionRevisionZero"

$env:WindowsLibPath="$CustomWinSDKRoot\UnionMetadata\$WinSDKVersionRevisionZero;$CustomWinSDKRoot\References\$WinSDKVersionRevisionZero"
$env:WindowsSdkBinPath="$CustomWinSDKRoot\bin"
$env:WindowsSDKLibVersion="$WinSDKVersionRevisionZero\"
$env:WindowsSdkVerBinPath="$CustomWinSDKRoot\bin\$WinSDKVersionRevisionZero"
$env:WindowsSDKVersion="$WinSDKVersionRevisionZero\"

$env:EXTERNAL_INCLUDE+=";$WinSDKIncludePath"
$env:INCLUDE+=";$WinSDKIncludePath"
$env:LIB+=";$WinSDKVerLibRoot\ucrt\$($Arch.ShortName);$WinSDKVerLibRoot\um\$($Arch.ShortName)"
$env:LIBPATH+=";$env:WindowsLibPath"
$env:PATH+=";$env:WindowsSdkVerBinPath\$($Arch.ShortName);$env:WindowsSdkBinPath\$($Arch.ShortName)"
$env:UCRTVersion=$WinSDKVersionRevisionZero
$env:UniversalCRTSdkDir=$CustomWinSDKRoot
 }
 }
}

functionEnsure-WindowsSDK {
# Assume we always have a default Windows SDK version available
if (-not$WinSDKVersion) { return }

# Check whether VsDevShell can already resolve the requested Windows SDK version
try {
 Isolate-EnvVars { Invoke-VsDevShell$HostArch }
return
 } catch {}

Write-Output"Windows SDK $WinSDKVersion not found. Downloading from nuget..."

# Assume the requested Windows SDK is not available and we need to download it
# Install the base nuget package that contains header files
$WinSDKBasePackageName="Microsoft.Windows.SDK.CPP"
Invoke-Program nuget install $WinSDKBasePackageName-Version $WinSDKVersion-OutputDirectory $NugetRoot

# Export to script scope so Invoke-VsDevShell can read it
$script:CustomWinSDKRoot="$NugetRoot\$WinSDKBasePackageName.$WinSDKVersion\c"

# Install each required arch-specific package and move the files under the base /lib directory
$WinSDKArchs=$SDKArchs.Clone()
if (-not ($HostArch-in$WinSDKArchs)) {
$WinSDKArchs+=$HostArch
 }

foreach ($Archin$WinSDKArchs) {
$WinSDKArchPackageName="$WinSDKBasePackageName.$($Arch.ShortName)"
Invoke-Program nuget install $WinSDKArchPackageName-Version $WinSDKVersion-OutputDirectory $NugetRoot
Copy-Directory"$NugetRoot\$WinSDKArchPackageName.$WinSDKVersion\c\*""$CustomWinSDKRoot\lib\$WinSDKVersionRevisionZero"
 }
}

functionEnsure-SwiftToolchain($Arch) {
if (-not (Test-Path$BinaryCache\wix-4.0.4.zip)) {
Write-Output"WiX not found. Downloading from nuget.org..."
Invoke-Programcurl.exe-sL https://www.nuget.org/api/v2/package/wix/4.0.4--output $BinaryCache\wix-4.0.4.zip --create-dirs
 }

if (-not$ToBatch) {
$SHA256=Get-FileHash-Path "$BinaryCache\wix-4.0.4.zip"-Algorithm SHA256
if ($SHA256.Hash-ne"A9CA12214E61BB49430A8C6E5E48AC5AE6F27DC82573B5306955C4D35F2D34E2") {
throw"WiX SHA256 mismatch ($($SHA256.Hash) vs A9CA12214E61BB49430A8C6E5E48AC5AE6F27DC82573B5306955C4D35F2D34E2)"
 }
 }

New-Item-ItemType Directory -ErrorAction Ignore $BinaryCache\wix-4.0.4|Out-Null
Write-Output"Extracting WiX..."
Expand-Archive-Path $BinaryCache\wix-4.0.4.zip -Destination $BinaryCache\wix-4.0.4-Force

if (-not (Test-Path"$BinaryCache\${PinnedToolchain}.exe")) {
Write-Output"Swift toolchain not found. Downloading from swift.org..."
 (New-Object Net.WebClient).DownloadFile($PinnedBuild,"$BinaryCache\${PinnedToolchain}.exe")
# Invoke-Program curl.exe -sL $PinnedBuild --output $BinaryCache\${PinnedToolchain}.exe --create-dirs
 }

if (-not$ToBatch) {
$SHA256=Get-FileHash-Path "$BinaryCache\${PinnedToolchain}.exe"-Algorithm SHA256
if ($SHA256.Hash-ne$PinnedSHA256) {
throw"SHA256 mismatch ($($SHA256.Hash) vs ${PinnedSHA256})"
 }
 }

New-Item-ItemType Directory -ErrorAction Ignore "$BinaryCache\toolchains"|Out-Null
Write-Output"Extracting Swift toolchain..."
Invoke-Program"$BinaryCache\wix-4.0.4\tools\net6.0\any\wix.exe"-- burn extract "$BinaryCache\${PinnedToolchain}.exe"-out "$BinaryCache\toolchains\"
Invoke-Program-OutNull msiexec.exe/qn /a "$BinaryCache\toolchains\a0" TARGETDIR="$BinaryCache\toolchains\${PinnedToolchain}"
Invoke-Program-OutNull msiexec.exe/qn /a "$BinaryCache\toolchains\a1" TARGETDIR="$BinaryCache\toolchains\${PinnedToolchain}"
Invoke-Program-OutNull msiexec.exe/qn /a "$BinaryCache\toolchains\a2" TARGETDIR="$BinaryCache\toolchains\${PinnedToolchain}"
Invoke-Program-OutNull msiexec.exe/qn /a "$BinaryCache\toolchains\a3" TARGETDIR="$BinaryCache\toolchains\${PinnedToolchain}"
}

functionTryAdd-KeyValue([hashtable]$Hashtable, [string]$Key, [string]$Value) {
if (-not$Hashtable.Contains($Key)) {
$Hashtable.Add($Key,$Value)
 }
}

functionAppend-FlagsDefine([hashtable]$Defines, [string]$Name, [string[]]$Value) {
if ($Defines.Contains($Name)) {
$Defines[$name] =@($Defines[$name]) +$Value
 } else {
$Defines.Add($Name,$Value)
 }
}

functionTest-CMakeAtLeast([int]$Major, [int]$Minor, [int]$Patch=0) {
if ($ToBatch) { return$false }

$CMakeVersionString=@(&cmake.exe--version)[0]
if (-not ($CMakeVersionString-match"^cmake version (\d+)\.(\d+)(?:\.(\d+))?")) {
throw"Unexpected CMake 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) { return0-gt$Patch }
return [int]$Matches.3-ge$Patch
}

functionBuild-CMakeProject {
 [CmdletBinding(PositionalBinding=$false)]
param(
 [string] $Src,
 [string] $Bin,
 [string] $InstallTo="",
 [hashtable] $Arch,
 [string] $Generator="Ninja",
 [string] $CacheScript="",
 [string[]] $UseMSVCCompilers=@(),# C,CXX
 [string[]] $UseBuiltCompilers=@(),# ASM,C,CXX,Swift
 [string[]] $UsePinnedCompilers=@(),# ASM,C,CXX,Swift
 [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' for arch '$($Arch.ShortName)'..."
 } else {
Write-Host-ForegroundColor Cyan "[$([DateTime]::Now.ToString("yyyy-MM-dd HH:mm:ss"))] Building '$Src' to '$Bin' for arch '$($Arch.ShortName)'..."
 }

$Stopwatch= [Diagnostics.Stopwatch]::StartNew()

# Enter the developer command shell early so we can resolve cmake.exe
# for version checks.
 Isolate-EnvVars {
Invoke-VsDevShell$Arch

# Add additional defines (unless already present)
$Defines=$Defines.Clone()

 TryAdd-KeyValue $Defines CMAKE_BUILD_TYPE Release
 TryAdd-KeyValue $Defines CMAKE_MT "mt"

$CFlags=@("/GS-","/Gw","/Gy","/Oi","/Oy","/Zc:inline")
if ($DebugInfo) { $CFlags+=if ($EnableCaching) { "/Z7" } else { "/Zi" } }
$CXXFlags=$CFlags.Clone() +"/Zc:__cplusplus"

if ($EnableCaching) {
$env:SCCACHE_DIRECT="true"
$env:SCCACHE_DIR="$BinaryCache\sccache"
 }

if ($UseMSVCCompilers.Contains("C")) {
 TryAdd-KeyValue $Defines CMAKE_C_COMPILER cl
if ($EnableCaching) {
 TryAdd-KeyValue $Defines CMAKE_C_COMPILER_LAUNCHER sccache
 }
 Append-FlagsDefine $Defines CMAKE_C_FLAGS $CFlags
 }
if ($UseMSVCCompilers.Contains("CXX")) {
 TryAdd-KeyValue $Defines CMAKE_CXX_COMPILER cl
if ($EnableCaching) {
 TryAdd-KeyValue $Defines CMAKE_CXX_COMPILER_LAUNCHER sccache
 }
 Append-FlagsDefine $Defines CMAKE_CXX_FLAGS $CXXFlags
 }
if ($UsePinnedCompilers.Contains("ASM") -Or$UseBuiltCompilers.Contains("ASM")) {
if ($UseBuiltCompilers.Contains("ASM")) {
 TryAdd-KeyValue $Defines CMAKE_ASM_COMPILER "$BinaryCache\1\bin\clang-cl.exe"
 } else {
 TryAdd-KeyValue $Defines CMAKE_ASM_COMPILER "$BinaryCache\toolchains\$PinnedToolchain\Library\Developer\Toolchains\unknown-Asserts-development.xctoolchain\usr\bin\clang-cl.exe"
 }
 Append-FlagsDefine $Defines CMAKE_ASM_FLAGS "--target=$($Arch.LLVMTarget)"
 TryAdd-KeyValue $Defines CMAKE_ASM_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_MultiThreadedDLL "/MD"
 }
if ($UsePinnedCompilers.Contains("C") -Or$UseBuiltCompilers.Contains("C")) {
if ($UseBuiltCompilers.Contains("C")) {
 TryAdd-KeyValue $Defines CMAKE_C_COMPILER "$BinaryCache\1\bin\clang-cl.exe"
 } else {
 TryAdd-KeyValue $Defines CMAKE_ASM_COMPILER "$BinaryCache\toolchains\$PinnedToolchain\Library\Developer\Toolchains\unknown-Asserts-development.xctoolchain\usr\bin\clang-cl.exe"
 }
 TryAdd-KeyValue $Defines CMAKE_C_COMPILER_TARGET $Arch.LLVMTarget

if (-not (Test-CMakeAtLeast-Major 3-Minor 26-Patch 3)) {
# Workaround for https://github.com/ninja-build/ninja/issues/2280
 TryAdd-KeyValue $Defines CMAKE_CL_SHOWINCLUDES_PREFIX "Note: including file: "
 }

if ($DebugInfo-and$CDebugFormat-eq"dwarf") {
 Append-FlagsDefine $Defines CMAKE_C_FLAGS "-gdwarf"
 }
 Append-FlagsDefine $Defines CMAKE_C_FLAGS $CFlags
 }
if ($UsePinnedCompilers.Contains("CXX") -Or$UseBuiltCompilers.Contains("CXX")) {
if ($UseBuiltCompilers.Contains("CXX")) {
 TryAdd-KeyValue $Defines CMAKE_CXX_COMPILER "$BinaryCache\1\bin\clang-cl.exe"
 } else {
 TryAdd-KeyValue $Defines CMAKE_ASM_COMPILER "$BinaryCache\toolchains\$PinnedToolchain\Library\Developer\Toolchains\unknown-Asserts-development.xctoolchain\usr\bin\clang-cl.exe"
 }
 TryAdd-KeyValue $Defines CMAKE_CXX_COMPILER_TARGET $Arch.LLVMTarget

if (-not (Test-CMakeAtLeast-Major 3-Minor 26-Patch 3)) {
# Workaround for https://github.com/ninja-build/ninja/issues/2280
 TryAdd-KeyValue $Defines CMAKE_CL_SHOWINCLUDES_PREFIX "Note: including file: "
 }

if ($DebugInfo-and$CDebugFormat-eq"dwarf") {
 Append-FlagsDefine $Defines CMAKE_CXX_FLAGS "-gdwarf"
 }
 Append-FlagsDefine $Defines CMAKE_CXX_FLAGS $CXXFlags
 }
if ($UsePinnedCompilers.Contains("Swift") -Or$UseBuiltCompilers.Contains("Swift")) {
$SwiftArgs=@()

if ($UseBuiltCompilers.Contains("Swift")) {
 TryAdd-KeyValue $Defines CMAKE_Swift_COMPILER "$BinaryCache\1\bin\swiftc.exe"
 } else {
 TryAdd-KeyValue $Defines CMAKE_Swift_COMPILER "$BinaryCache\toolchains\$PinnedToolchain\Library\Developer\Toolchains\unknown-Asserts-development.xctoolchain\usr\bin\swiftc.exe"
 }
 TryAdd-KeyValue $Defines CMAKE_Swift_COMPILER_TARGET $Arch.LLVMTarget
if ($UseBuiltCompilers.Contains("Swift")) {
if ($SwiftSDK-ne"") {
$SwiftArgs+=@("-sdk",$SwiftSDK)
 } else {
$RuntimeBinaryCache=Get-ProjectBinaryCache$Arch1
$SwiftResourceDir="${RuntimeBinaryCache}\lib\swift"

$SwiftArgs+=@("-resource-dir","$SwiftResourceDir")
$SwiftArgs+=@("-L","$SwiftResourceDir\windows")
$SwiftArgs+=@("-vfsoverlay","$RuntimeBinaryCache\stdlib\windows-vfs-overlay.yaml")
 }
 } else {
$SwiftArgs+=@("-sdk","$BinaryCache\toolchains\$PinnedToolchain\Library\Developer\Platforms\Windows.platform\Developer\SDKs\Windows.sdk")
 }

# Debug Information
if ($DebugInfo) {
if ($SwiftDebugFormat-eq"dwarf") {
$SwiftArgs+=@("-g","-Xlinker","/DEBUG:DWARF","-use-ld=lld-link")
 } else {
$SwiftArgs+=@("-g","-debug-info-format=codeview","-Xlinker","-debug")
 }
 } else {
$SwiftArgs+="-gnone"
 }
$SwiftArgs+=@("-Xlinker","/INCREMENTAL:NO")

# Swift Requries COMDAT folding and de-duplication
$SwiftArgs+=@("-Xlinker","/OPT:REF")
$SwiftArgs+=@("-Xlinker","/OPT:ICF")
 Append-FlagsDefine $Defines CMAKE_Swift_FLAGS $SwiftArgs

# Workaround CMake 3.26+ enabling `-wmo` by default on release builds
 Append-FlagsDefine $Defines CMAKE_Swift_FLAGS_RELEASE "-O"
 Append-FlagsDefine $Defines CMAKE_Swift_FLAGS_RELWITHDEBINFO "-O"
 }
if (""-ne$InstallTo) {
 TryAdd-KeyValue $Defines CMAKE_INSTALL_PREFIX $InstallTo
 }

# Generate the project
$cmakeGenerateArgs=@("-B",$Bin,"-S",$Src,"-G",$Generator)
if (""-ne$CacheScript) {
$cmakeGenerateArgs+=@("-C",$CacheScript)
 }
foreach ($Definein ($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 ($Argin$Define.Value) {
if ($Value.Length-gt0) {
$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="$($HostArch.SDKInstallRoot)\usr\bin;$ToolchainInstallRoot\usr\bin;${env:Path}"
 }
Invoke-Programcmake.exe@cmakeGenerateArgs

# Build all requested targets
foreach ($Targetin$BuildTargets) {
if ($Target-eq"default") {
Invoke-Programcmake.exe--build $Bin
 } else {
Invoke-Programcmake.exe--build $Bin--target $Target
 }
 }

if (""-ne$InstallTo) {
Invoke-Programcmake.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' for arch '$($Arch.ShortName)' in $($Stopwatch.Elapsed)"
Write-Host""
 }
}

functionBuild-SPMProject {
 [CmdletBinding(PositionalBinding=$false)]
param(
 [string] $Src,
 [string] $Bin,
 [hashtable] $Arch,
 [Parameter(ValueFromRemainingArguments)]
 [string[]] $AdditionalArguments
 )

if ($ToBatch) {
Write-Output""
Write-Output"echo Building '$Src' to '$Bin' for arch '$($Arch.ShortName)'..."
 } else {
Write-Host-ForegroundColor Cyan "[$([DateTime]::Now.ToString("yyyy-MM-dd HH:mm:ss"))] Building '$Src' to '$Bin' for arch '$($Arch.ShortName)'..."
 }

$Stopwatch= [Diagnostics.Stopwatch]::StartNew()

 Isolate-EnvVars {
$env:Path="$RuntimeInstallRoot\usr\bin;$ToolchainInstallRoot\usr\bin;${env:Path}"
$env:SDKROOT=$SDKInstallRoot

$Arguments=@(
"--scratch-path",$Bin,
"--package-path",$Src,
"-c","release",
"-Xbuild-tools-swiftc","-I$SDKInstallRoot\usr\lib\swift",
"-Xbuild-tools-swiftc","-L$SDKInstallRoot\usr\lib\swift\windows",
"-Xcc","-I$SDKInstallRoot\usr\lib\swift",
"-Xlinker","-L$SDKInstallRoot\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")
 }

Invoke-Program"$ToolchainInstallRoot\usr\bin\swift.exe""build"@Arguments@AdditionalArguments
 }

if (-not$ToBatch) {
Write-Host-ForegroundColor Cyan "[$([DateTime]::Now.ToString("yyyy-MM-dd HH:mm:ss"))] Finished building '$Src' to '$Bin' for arch '$($Arch.ShortName)' in $($Stopwatch.Elapsed)"
Write-Host""
 }
}

functionBuild-WiXProject() {
 [CmdletBinding(PositionalBinding=$false)]
param(
 [Parameter(Position=0,Mandatory=$true)]
 [string]$FileName,
 [Parameter(Mandatory=$true)]
 [hashtable]$Arch,
 [switch]$Bundle,
 [hashtable]$Properties=@{}
 )

$ArchName=$Arch.VSName

$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 versionning suffixes
$ProductVersionArg= [regex]::Replace($ProductVersion,"[-+].*","")
 }

$Properties=$Properties.Clone()
 TryAdd-KeyValue $Properties Configuration Release
 TryAdd-KeyValue $Properties BaseOutputPath "$($Arch.BinaryCache)\installer\"
 TryAdd-KeyValue $Properties ProductArchitecture $ArchName
 TryAdd-KeyValue $Properties ProductVersion $ProductVersionArg

$MSBuildArgs=@("$SourceCache\swift-installer-scripts\platforms\Windows\$FileName")
$MSBuildArgs+="-noLogo"
$MSBuildArgs+="-restore"
$MSBuildArgs+="-maxCpuCount"
foreach ($Propertyin$Properties.GetEnumerator()) {
if ($Property.Value.Contains("")) {
$MSBuildArgs+="-p:$($Property.Key)=$($Property.Value.Replace('\','\\'))"
 } else {
$MSBuildArgs+="-p:$($Property.Key)=$($Property.Value)"
 }
 }
$MSBuildArgs+="-binaryLogger:$($Arch.BinaryCache)\msi\$ArchName-$([System.IO.Path]::GetFileNameWithoutExtension($FileName)).binlog"
$MSBuildArgs+="-detailedSummary:False"

Invoke-Program$msbuild@MSBuildArgs
}

functionBuild-BuildTools($Arch) {
Build-CMakeProject`
-Src $SourceCache\llvm-project\llvm `
-Bin $BinaryCache\0`
-Arch $Arch`
-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 @{
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="cmark;swift";
LLVM_EXTERNAL_CMARK_SOURCE_DIR="$SourceCache\cmark";
LLVM_EXTERNAL_SWIFT_SOURCE_DIR="$SourceCache\swift";
SWIFT_BUILD_DYNAMIC_SDK_OVERLAY="NO";
SWIFT_BUILD_DYNAMIC_STDLIB="NO";
SWIFT_BUILD_REMOTE_MIRROR="NO";
SWIFT_BUILD_STATIC_SDK_OVERLAY="NO";
SWIFT_BUILD_STATIC_STDLIB="NO";
SWIFT_INCLUDE_DOCS="NO";
SWIFT_PATH_TO_LIBDISPATCH_SOURCE="$SourceCache\swift-corelibs-libdispatch";
SWIFT_PATH_TO_SWIFT_SYNTAX_SOURCE="$SourceCache\swift-syntax";
 }
}

functionBuild-Compilers($Arch, [switch]$Test=$false) {
 Isolate-EnvVars {
if ($Test) {
$LibdispatchBinDir="$BinaryCache\1\tools\swift\libdispatch-windows-$($Arch.LLVMName)-prefix\bin"
$env:Path="$LibdispatchBinDir;$BinaryCache\1\bin;$env:Path;$UnixToolsBinDir"
$Targets=@("check-swift")
$TestingDefines=@{
SWIFT_BUILD_DYNAMIC_SDK_OVERLAY="YES";
SWIFT_BUILD_DYNAMIC_STDLIB="YES";
SWIFT_BUILD_REMOTE_MIRROR="YES";
SWIFT_NATIVE_SWIFT_TOOLS_PATH="";
 }
 } else {
$Targets=@("distribution","install-distribution")
$TestingDefines=@{
SWIFT_BUILD_DYNAMIC_SDK_OVERLAY="NO";
SWIFT_BUILD_DYNAMIC_STDLIB="NO";
SWIFT_BUILD_REMOTE_MIRROR="NO";
SWIFT_NATIVE_SWIFT_TOOLS_PATH="$BinaryCache\0\bin";
 }
 }

$env:Path="$BinaryCache\toolchains\$PinnedToolchain\PFiles64\Swift\runtime-development\usr\bin;${env:Path}"

Build-CMakeProject`
-Src $SourceCache\llvm-project\llvm `
-Bin $BinaryCache\1`
-Arch $Arch`
-UseMSVCCompilers C,CXX `
-BuildTargets $Targets`
-CacheScript $SourceCache\swift\cmake\caches\Windows-$($Arch.LLVMName).cmake `
-Defines ($TestingDefines+@{
CLANG_TABLEGEN="$BinaryCache\0\bin\clang-tblgen.exe";
CLANG_TIDY_CONFUSABLE_CHARS_GEN="$BinaryCache\0\bin\clang-tidy-confusable-chars-gen.exe";
CMAKE_INSTALL_PREFIX="$($Arch.ToolchainInstallRoot)\usr";
CMAKE_Swift_COMPILER="$BinaryCache\toolchains\$PinnedToolchain\Library\Developer\Toolchains\unknown-Asserts-development.xctoolchain\usr\bin\swiftc.exe";
CMAKE_Swift_FLAGS=@("-sdk","$BinaryCache\toolchains\$PinnedToolchain\Library\Developer\Platforms\Windows.platform\Developer\SDKs\Windows.sdk");
LLDB_PYTHON_EXE_RELATIVE_PATH="python.exe";
LLDB_PYTHON_EXT_SUFFIX=".pyd";
LLDB_PYTHON_RELATIVE_PATH="lib/site-packages";
LLDB_TABLEGEN="$BinaryCache\0\bin\lldb-tblgen.exe";
LLVM_CONFIG_PATH="$BinaryCache\0\bin\llvm-config.exe";
LLVM_EXTERNAL_CMARK_SOURCE_DIR="$SourceCache\cmark";
LLVM_EXTERNAL_SWIFT_SOURCE_DIR="$SourceCache\swift";
LLVM_NATIVE_TOOL_DIR="$BinaryCache\0\bin";
LLVM_TABLEGEN="$BinaryCache\0\bin\llvm-tblgen.exe";
LLVM_USE_HOST_TOOLS="NO";
SWIFT_BUILD_SWIFT_SYNTAX="YES";
SWIFT_CLANG_LOCATION="$BinaryCache\toolchains\$PinnedToolchain\Library\Developer\Toolchains\unknown-Asserts-development.xctoolchain\usr\bin";
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_PATH_TO_LIBDISPATCH_SOURCE="$SourceCache\swift-corelibs-libdispatch";
SWIFT_PATH_TO_SWIFT_SYNTAX_SOURCE="$SourceCache\swift-syntax";
SWIFT_PATH_TO_STRING_PROCESSING_SOURCE="$SourceCache\swift-experimental-string-processing";
SWIFT_PATH_TO_SWIFT_SDK="$BinaryCache\toolchains\$PinnedToolchain\Library\Developer\Platforms\Windows.platform\Developer\SDKs\Windows.sdk";
 })
 }
}

functionBuild-LLVM($Arch) {
Build-CMakeProject`
-Src $SourceCache\llvm-project\llvm `
-Bin (Get-ProjectBinaryCache$Arch0) `
-Arch $Arch`
-Defines @{
LLVM_HOST_TRIPLE=$Arch.LLVMTarget;
 }
}

functionBuild-ZLib($Arch) {
$ArchName=$Arch.ShortName

Build-CMakeProject`
-Src $SourceCache\zlib `
-Bin "$($Arch.BinaryCache)\zlib-1.3"`
-InstallTo $LibraryRoot\zlib-1.3\usr `
-Arch $Arch`
-BuildTargets default`
-Defines @{
BUILD_SHARED_LIBS="NO";
INSTALL_BIN_DIR="$LibraryRoot\zlib-1.3\usr\bin\$ArchName";
INSTALL_LIB_DIR="$LibraryRoot\zlib-1.3\usr\lib\$ArchName";
 }
}

functionBuild-XML2($Arch) {
$ArchName=$Arch.ShortName

Build-CMakeProject`
-Src $SourceCache\libxml2 `
-Bin "$($Arch.BinaryCache)\libxml2-2.11.5"`
-InstallTo "$LibraryRoot\libxml2-2.11.5\usr"`
-Arch $Arch`
-BuildTargets default`
-Defines @{
BUILD_SHARED_LIBS="NO";
CMAKE_INSTALL_BINDIR="bin/$ArchName";
CMAKE_INSTALL_LIBDIR="lib/$ArchName";
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";
 }
}

functionBuild-CURL($Arch) {
$ArchName=$Arch.ShortName

Build-CMakeProject`
-Src $SourceCache\curl `
-Bin "$($Arch.BinaryCache)\curl-8.4.0"`
-InstallTo "$LibraryRoot\curl-8.4.0\usr"`
-Arch $Arch`
-BuildTargets default`
-Defines @{
BUILD_SHARED_LIBS="NO";
BUILD_TESTING="NO";
CMAKE_INSTALL_LIBDIR="lib/$ArchName";
BUILD_CURL_EXE="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_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_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";