[DNM][WIP] Implement Windows toolchain

Package.resolved

@@ -5,9 +5,9 @@
         "package": "swift-argument-parser",
         "repositoryURL": "https://github.com/apple/swift-argument-parser.git",
         "state": {
-          "branch": null,
-          "revision": "92646c0cdbaca076c8d3d0207891785b3379cbff",
-          "version": "0.3.1"
+          "branch": "main",
+          "revision": "4273ad222e6c51969e8585541f9da5187ad94e47",
+          "version": null
         }
       },
       {

Package.swift

@@ -101,7 +101,7 @@ if ProcessInfo.processInfo.environment["SWIFTCI_USE_LOCAL_DEPS"] == nil {
     // The 'swift-argument-parser' version declared here must match that
     // used by 'swift-package-manager' and 'sourcekit-lsp'. Please coordinate
     // dependency version changes here with those projects.
-    .package(url: "https://github.com/apple/swift-argument-parser.git", .upToNextMinor(from: "0.3.1")),
+    .package(url: "https://github.com/apple/swift-argument-parser.git", .branch("main")),
     ]
 } else {
     package.dependencies += [

README.md

@@ -163,7 +163,7 @@ The goal of the new Swift driver is to provide a drop-in replacement for the exi
 * Platform support
   * [x] Teach the `DarwinToolchain` to also handle iOS, tvOS, watchOS
   * [x] Fill out the `GenericUnixToolchain` toolchain to get it working
-  * [ ] Implement a `WindowsToolchain`
+  * [x] Implement a `WindowsToolchain`
   * [x] Implement proper tokenization for response files
 * Compilation modes
   * [x] Batch mode

Sources/SwiftDriver/CMakeLists.txt

@@ -1,6 +1,6 @@
 # This source file is part of the Swift.org open source project
 #
-# Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+# Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
 # Licensed under Apache License v2.0 with Runtime Library Exception
 #
 # See http://swift.org/LICENSE.txt for license information
@@ -71,11 +71,13 @@ add_library(SwiftDriver
   Jobs/Toolchain+LinkerSupport.swift
   Jobs/VerifyDebugInfoJob.swift
   Jobs/VerifyModuleInterfaceJob.swift
+  Jobs/WindowsToolchain+LinkerSupport.swift
   Jobs/WebAssemblyToolchain+LinkerSupport.swift
 
   Toolchains/DarwinToolchain.swift
   Toolchains/GenericUnixToolchain.swift
   Toolchains/Toolchain.swift
+  Toolchains/WindowsToolchain.swift
   Toolchains/WebAssemblyToolchain.swift
 
   Utilities/DOTJobGraphSerializer.swift

Sources/SwiftDriver/Driver/Driver.swift

@@ -280,7 +280,7 @@ public struct Driver {
   public static let stderrDiagnosticsHandler: DiagnosticsEngine.DiagnosticsHandler = { diagnostic in
     let stream = stderrStream
     if !(diagnostic.location is UnknownLocation) {
-        stream <<< diagnostic.location.description <<< ": "
+      stream <<< diagnostic.location.description <<< ": "
     }
 
     switch diagnostic.message.behavior {
@@ -293,7 +293,7 @@ public struct Driver {
     case .remark:
       stream <<< "remark: "
     case .ignored:
-        break
+      break
     }
 
     stream <<< diagnostic.localizedDescription <<< "\n"
@@ -447,6 +447,9 @@ public struct Driver {
     self.numParallelJobs = Self.determineNumParallelJobs(&parsedOptions, diagnosticsEngine: diagnosticEngine, env: env)
 
     Self.validateWarningControlArgs(&parsedOptions, diagnosticEngine: diagnosticEngine)
+    Self.validateCRuntimeArgs(&parsedOptions,
+                              diagnosticEngine: diagnosticsEngine,
+                              targetTriple: self.frontendTargetInfo.target.triple)
     Self.validateProfilingArgs(&parsedOptions,
                                fileSystem: fileSystem,
                                workingDirectory: workingDirectory,
@@ -741,7 +744,7 @@ extension Driver {
   ///
   /// - Parameter content: response file's content to be tokenized.
   private static func tokenizeResponseFile(_ content: String) -> [String] {
-    #if !os(macOS) && !os(Linux) && !os(Android)
+    #if !os(macOS) && !os(Linux) && !os(Android) && !os(Windows)
       #warning("Response file tokenization unimplemented for platform; behavior may be incorrect")
     #endif
     return content.split { $0 == "\n" || $0 == "\r\n" }
@@ -1590,6 +1593,11 @@ extension Driver {
         sanitizerSupported = false
       }
 
+      // Currently only ASAN is supported on Windows.
+      if sanitizer != .address && targetTriple.isWindows {
+        sanitizerSupported = false
+      }
+
       if !sanitizerSupported {
         diagnosticEngine.emit(
           .error_unsupported_opt_for_target(
@@ -1953,6 +1961,14 @@ extension Driver {
     }
   }
 
+  static func validateCRuntimeArgs(_ parsedOptions: inout ParsedOptions,
+                                   diagnosticEngine: DiagnosticsEngine,
+                                   targetTriple: Triple) {
+    if parsedOptions.hasArgument(.libc) && !targetTriple.isWindows {
+      diagnosticEngine.emit(.error_unsupported_opt_for_target(arg: "-libc", target: targetTriple))
+    }
+  }
+
   static func validateProfilingArgs(_ parsedOptions: inout ParsedOptions,
                                     fileSystem: FileSystem,
                                     workingDirectory: AbsolutePath?,
@@ -2040,7 +2056,7 @@ extension Triple {
     case .wasi:
       return WebAssemblyToolchain.self
     case .win32:
-      fatalError("Windows target not supported yet")
+      return WindowsToolchain.self
     default:
       diagnosticsEngine.emit(.error_unknown_target(triple))
       throw Diagnostics.fatalError
@@ -2053,7 +2069,7 @@ extension Driver {
   #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
   static let defaultToolchainType: Toolchain.Type = DarwinToolchain.self
   #elseif os(Windows)
-  static let defaultToolchainType: Toolchain.Type = { fatalError("Windows target not supported yet") }()
+  static let defaultToolchainType: Toolchain.Type = WindowsToolchain.self
   #else
   static let defaultToolchainType: Toolchain.Type = GenericUnixToolchain.self
   #endif

Sources/SwiftDriver/Jobs/CommandLineArguments.swift

@@ -165,10 +165,10 @@ extension Array where Element == Job.ArgTemplate {
   public var joinedArguments: String {
     return self.map {
       switch $0 {
-        case .flag(let string):
-          return string.spm_shellEscaped()
-        case .path(let path):
-          return path.name.spm_shellEscaped()
+      case .flag(let string):
+        return string.spm_shellEscaped()
+      case .path(let path):
+        return path.name.spm_shellEscaped()
       case .responseFilePath(let path):
         return "@\(path.name.spm_shellEscaped())"
       case let .joinedOptionAndPath(option, path):

Sources/SwiftDriver/Jobs/Toolchain+InterpreterSupport.swift

@@ -81,3 +81,14 @@ extension GenericUnixToolchain {
     return envVars
   }
 }
+
+extension WindowsToolchain {
+  public func platformSpecificInterpreterEnvironmentVariables(
+    env: [String : String],
+    parsedOptions: inout ParsedOptions,
+    sdkPath: VirtualPath?,
+    targetInfo: FrontendTargetInfo) throws -> [String: String] {
+    // TODO: See whether Windows needs `platformSpecificInterpreterEnvironmentVariables`
+    return [:]
+  }
+}

Sources/SwiftDriver/Jobs/Toolchain+LinkerSupport.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -50,7 +50,11 @@ extension Toolchain {
         result.append(sdkPath.appending(components: "System", "iOSSupport", "usr", "lib", "swift"))
       }
 
-      result.append(sdkPath.appending(components: "usr", "lib", "swift"))
+      if (triple.isWindows) {
+        result.append(sdkPath.appending(components: "usr", "lib", "swift", "windows"))
+      } else {
+        result.append(sdkPath.appending(components: "usr", "lib", "swift"))
+      }
     }
 
     return result
@@ -225,3 +229,5 @@ extension DarwinToolchain {
   }
 
 }
+
+// TODO: Implement `addArgsToLinkStdlib` for `WindowsToolchain`.

Sources/SwiftDriver/Jobs/WindowsToolchain+LinkerSupport.swift

@@ -0,0 +1,186 @@
+//===---------------- WindowsToolchain+LinkerSupport.swift ----------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+import TSCBasic
+import SwiftOptions
+
+extension WindowsToolchain {
+  public func addPlatformSpecificLinkerArgs(
+    to commandLine: inout [Job.ArgTemplate],
+    parsedOptions: inout ParsedOptions,
+    linkerOutputType: LinkOutputType,
+    inputs: [TypedVirtualPath],
+    outputFile: VirtualPath,
+    shouldUseInputFileList: Bool,
+    lto: LTOKind?,
+    sanitizers: Set<Sanitizer>,
+    targetInfo: FrontendTargetInfo
+  ) throws -> AbsolutePath {
+    let targetTriple = targetInfo.target.triple
+
+    switch linkerOutputType {
+    case .dynamicLibrary:
+      commandLine.appendFlags("-Xlinker", "-dll")
+      fallthrough
+    case .executable:
+      if !targetTriple.triple.isEmpty {
+        commandLine.appendFlag("-target")
+        commandLine.appendFlag(targetTriple.triple)
+      }
+      // Configure the toolchain.
+      //
+      // By default use the system `clang` to perform the link.  We use `clang` for
+      // the driver here because we do not wish to select a particular C++ runtime.
+      // Furthermore, until C++ interop is enabled, we cannot have a dependency on
+      // C++ code from pure Swift code.  If linked libraries are C++ based, they
+      // should properly link C++.  In the case of static linking, the user can
+      // explicitly specify the C++ runtime to link against.  This is particularly
+      // important for platforms like android where as it is a Linux platform, the
+      // default C++ runtime is `libstdc++` which is unsupported on the target but
+      // as the builds are usually cross-compiled from Linux, libstdc++ is going to
+      // be present.  This results in linking the wrong version of libstdc++
+      // generating invalid binaries.  It is also possible to use different C++
+      // runtimes than the default C++ runtime for the platform (e.g. libc++ on
+      // Windows rather than msvcprt).  When C++ interop is enabled, we will need to
+      // surface this via a driver flag.  For now, opt for the simpler approach of
+      // just using `clang` and avoid a dependency on the C++ runtime.
+      var clangPath = try getToolPath(.clang)
+      if let toolsDirPath = parsedOptions.getLastArgument(.toolsDirectory) {
+        // FIXME: What if this isn't an absolute path?
+        let toolsDir = try AbsolutePath(validating: toolsDirPath.asSingle)
+
+        // If there is a clang in the toolchain folder, use that instead.
+        if let tool = lookupExecutablePath(filename: "clang.exe", searchPaths: [toolsDir]) {
+          clangPath = tool
+        }
+
+        // Look for binutils in the toolchain folder.
+        commandLine.appendFlag("-B")
+        commandLine.appendPath(toolsDir)
+      }
+
+      let linker: String
+      if let arg = parsedOptions.getLastArgument(.useLd) {
+        linker = arg.asSingle
+      } else {
+        linker = "link"
+      }
+      commandLine.appendFlag("-fuse-ld=\(linker)")
+
+      if let crt = parsedOptions.getLastArgument(.libc) {
+        switch crt.asSingle {
+        case "MT": commandLine.appendFlags("-Xlinker", "-defaultlib:libcmt")
+        case "MTd": commandLine.appendFlags("-Xlinker", "-defaultlib:libcmtd")
+        case "MD": commandLine.appendFlags("-Xlinker", "-defaultlib:msvcrt")
+        case "MDd": commandLine.appendFlags("-Xlinker", "-defaultlib:msvcrtd")
+        default: fatalError("Invalid C runtime value should be filtered")
+        }
+      } else {
+        commandLine.appendFlags("-Xlinker", "-defaultlib:msvcrt")
+      }
+
+      let staticStdlib = parsedOptions.hasFlag(positive: .staticStdlib,
+                                               negative: .noStaticStdlib,
+                                                default: false)
+      let staticExecutable = parsedOptions.hasFlag(positive: .staticExecutable,
+                                                   negative: .noStaticExecutable,
+                                                    default: false)
+      let hasRuntimeArgs = !(staticStdlib || staticExecutable)
+
+      let runtimePaths = try runtimeLibraryPaths(
+        for: targetInfo,
+        parsedOptions: &parsedOptions,
+        sdkPath: targetInfo.sdkPath?.path,
+        isShared: hasRuntimeArgs
+      )
+
+      guard let swiftrtPath = targetInfo.sdkPath?.path
+        .appending(
+          components: "usr", "lib", "swift", "windows",
+          targetTriple.archName,
+          "swiftrt.obj") else {
+        throw ToolchainValidationError.sdkNotFound
+      }
+      commandLine.appendPath(swiftrtPath)
+
+      let inputFiles: [Job.ArgTemplate] = inputs.compactMap { input in
+        // Autolink inputs are handled specially
+        if input.type == .autolink {
+          return .responseFilePath(input.file)
+        } else if input.type == .object {
+          return .path(input.file)
+        } else {
+          return nil
+        }
+      }
+      commandLine.append(contentsOf: inputFiles)
+
+      let fSystemArgs = parsedOptions.arguments(for: .F, .Fsystem)
+      for opt in fSystemArgs {
+        if opt.option == .Fsystem {
+          commandLine.appendFlag("-iframework")
+        } else {
+          commandLine.appendFlag(.F)
+        }
+        commandLine.appendPath(try VirtualPath(path: opt.argument.asSingle))
+      }
+
+      // Add the runtime library link paths.
+      for path in runtimePaths {
+        commandLine.appendFlag(.L)
+        commandLine.appendPath(path.appending(component: targetTriple.archName))
+      }
+
+      if hasRuntimeArgs {
+        commandLine.appendFlag("-lswiftCore")
+      }
+
+      // Explicitly pass the target to the linker
+      commandLine.appendFlags("-target", targetTriple.triple)
+
+      // Delegate to Clang for sanitizers. It will figure out the correct linker
+      // options.
+      if linkerOutputType == .executable && !sanitizers.isEmpty {
+        let sanitizerNames = sanitizers
+          .map { $0.rawValue }
+          .sorted() // Sort so we get a stable, testable order
+          .joined(separator: ",")
+        commandLine.appendFlag("-fsanitize=\(sanitizerNames)")
+
+        // The TSan runtime depends on the blocks runtime and libdispatch.
+        if sanitizers.contains(.thread) {
+          commandLine.appendFlag("-lBlocksRuntime")
+          commandLine.appendFlag("-ldispatch")
+        }
+      }
+
+      // Run clang++ in verbose mode if "-v" is set
+      try commandLine.appendLast(.v, from: &parsedOptions)
+
+      // These custom arguments should be right before the object file at the
+      // end.
+      try commandLine.append(
+        contentsOf: parsedOptions.arguments(in: .linkerOption)
+      )
+      try commandLine.appendAllArguments(.Xlinker, from: &parsedOptions)
+      try commandLine.appendAllArguments(.XclangLinker, from: &parsedOptions)
+
+      // This should be the last option, for convenience in checking output.
+      commandLine.appendFlag(.o)
+      commandLine.appendPath(outputFile)
+      return clangPath
+    case .staticLibrary:
+      commandLine.append(.joinedOptionAndPath("-out:", outputFile))
+      commandLine.append(contentsOf: inputs.map { .path($0.file) })
+      return try getToolPath(.staticLinker(lto))
+    }
+  }
+}

Sources/SwiftDriver/Toolchains/DarwinToolchain.swift

@@ -20,15 +20,15 @@ import SwiftOptions
 @_spi(Testing) public final class DarwinToolchain: Toolchain {
   public let env: [String: String]
 
-  /// Doubles as path cache and point for overriding normal lookup
-  private var toolPaths = [Tool: AbsolutePath]()
-
   /// The executor used to run processes used to find tools and retrieve target info.
   public let executor: DriverExecutor
 
   /// The file system to use for any file operations.
   public let fileSystem: FileSystem
 
+  /// Doubles as path cache and point for overriding normal lookup
+  private var toolPaths = [Tool: AbsolutePath]()
+
   // An externally provided path from where we should find tools like ld
   public let toolDirectory: AbsolutePath?