synchronise

Author: compnerd

utils/build.ps1

@@ -42,6 +42,11 @@ An array of architectures for which the Swift SDK should be built.
 The product version to be used when building the installer.
 Supports semantic version strings.
 
+.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 SkipBuild
 If set, does not run the build phase.
 
@@ -78,6 +83,7 @@ param(
   [string] $SwiftDebugFormat = "dwarf",
   [string[]] $SDKs = @("X64","X86","Arm64"),
   [string] $ProductVersion = "0.0.0",
+  [string] $WinSDKVersion = "",
   [switch] $SkipBuild = $false,
   [switch] $SkipRedistInstall = $false,
   [switch] $SkipPackaging = $false,
@@ -92,23 +98,28 @@ 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 -ne $null -or $env:VSCMD_ARG_TGT_ARCH -ne $null) {
+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 = ""
+$env:SDKROOT = ""
 $NativeProcessorArchName = $env:PROCESSOR_ARCHITEW6432
 if ($null -eq $NativeProcessorArchName) { $NativeProcessorArchName = $env:PROCESSOR_ARCHITECTURE }
 
-$vswhere = "${Env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe"
+# 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"
+$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)) {
@@ -192,6 +203,8 @@ function Get-InstallDir($Arch) {
   return "$ImageRoot\$ProgramFilesName\Swift"
 }
 
+$NugetRoot = "$BinaryCache\nuget"
+
 $LibraryRoot = "$ImageRoot\Library"
 $ToolchainInstallRoot = "$(Get-InstallDir $HostArch)\Toolchains\$ProductVersion+Asserts"
 $PlatformInstallRoot = "$(Get-InstallDir $HostArch)\Platforms\Windows.platform"
@@ -203,20 +216,33 @@ $SDKInstallRoot = "$PlatformInstallRoot\Developer\SDKs\Windows.sdk"
 $HostArch.ToolchainInstallRoot = $ToolchainInstallRoot
 
 # Resolve the architectures received as argument
-$SDKArchs = $SDKs | ForEach-Object {
+$SDKArchs = @($SDKs | ForEach-Object {
   switch ($_) {
     "X64" { $ArchX64 }
     "X86" { $ArchX86 }
     "Arm64" { $ArchArm64 }
     default { throw "Unknown architecture $_" }
   }
-}
+})
 
 # Build functions
 function Get-ProjectBinaryCache($Arch, $ID) {
   return "$BinaryCache\" + ($Arch.BuildID + $ID)
 }
 
+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)
+  New-Item -ItemType Directory -ErrorAction Ignore $DstDir | Out-Null
+  Copy-Item -Force $Src $Dst
+}
+
+function Copy-Directory($Src, $Dst) {
+  New-Item -ItemType Directory -ErrorAction Ignore $Dst | Out-Null
+  Copy-Item -Force -Recurse $Src $Dst
+}
+
 function Invoke-Program() {
   [CmdletBinding(PositionalBinding = $false)]
   param(
@@ -305,12 +331,73 @@ function Isolate-EnvVars([scriptblock]$Block) {
 }
 
 function Invoke-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`" -no_logo -host_arch=$($HostArch.VSName) -arch=$($Arch.VSName)"
+    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 "-no_logo -host_arch=$($HostArch.VSName) -arch=$($Arch.VSName)"
+    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
+    }
+  }
+}
+
+function Ensure-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 ($Arch in $WinSDKArchs) {
+    $WinSDKArchPackageName = "$WinSDKBasePackageName.$($Arch.ShortName)"
+    Invoke-Program nuget install $WinSDKArchPackageName -Version $WinSDKVersion -OutputDirectory $NugetRoot
+    Copy-Directory "$NugetRoot\$WinSDKArchPackageName.$WinSDKVersion\c\*" "$CustomWinSDKRoot\lib\$WinSDKVersionRevisionZero"
   }
 }
 
@@ -978,19 +1065,6 @@ function Build-XCTest($Arch, [switch]$Test = $false) {
   }
 }
 
-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)
-  New-Item -ItemType Directory -ErrorAction Ignore $DstDir | Out-Null
-  Copy-Item -Force $Src $Dst
-}
-
-function Copy-Directory($Src, $Dst) {
-  New-Item -ItemType Directory -ErrorAction Ignore $Dst | Out-Null
-  Copy-Item -Force -Recurse $Src $Dst
-}
-
 # 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.
@@ -1414,6 +1488,9 @@ function Build-Installer() {
     SWIFT_FORMAT_BUILD = "$($HostArch.BinaryCache)\swift-format\release";
     INCLUDE_SWIFT_INSPECT = "true";
     SWIFT_INSPECT_BUILD = "$($HostArch.BinaryCache)\swift-inspect\release";
+    INCLUDE_SWIFT_DOCC = "true";
+    SWIFT_DOCC_BUILD = "$($HostArch.BinaryCache)\swift-docc\release";
+    SWIFT_DOCC_RENDER_ARTIFACT_ROOT = "${SourceCache}\swift-docc-render-artifact";
   }
 
   foreach ($Arch in $SDKArchs) {
@@ -1432,6 +1509,10 @@ function Build-Installer() {
 
 #-------------------------------------------------------------------
 
+if (-not $SkipBuild) {
+  Ensure-WindowsSDK
+}
+
 if (-not $SkipBuild) {
   Build-BuildTools $HostArch
   Build-Compilers $HostArch