SwiftDriver: initial (incomplete) windows port

This is sufficient to build on Windows, and the resulting driver is able
to somewhat function.  The tests are still not usable due to assumptions
about path which do not hold and the insufficiency of the path
representation in tools-support-core.  This is likely best approached by
replacing the use of `Path` from t-s-c with the representation in
system.  However, this allows some attempt to validate the swift-driver
which is increasingly becoming required for s-p-m, and thus unblocks
further work.

Author: compnerd

Sources/SwiftDriver/CMakeLists.txt

@@ -86,12 +86,14 @@ add_library(SwiftDriver
   Jobs/VerifyDebugInfoJob.swift
   Jobs/VerifyModuleInterfaceJob.swift
   Jobs/WebAssemblyToolchain+LinkerSupport.swift
+  Jobs/WindowsToolchain+LinkerSupport.swift
   Jobs/PrebuiltModulesJob.swift
 
   Toolchains/DarwinToolchain.swift
   Toolchains/GenericUnixToolchain.swift
   Toolchains/Toolchain.swift
   Toolchains/WebAssemblyToolchain.swift
+  Toolchains/WindowsToolchain.swift
 
   Utilities/DOTJobGraphSerializer.swift
   Utilities/DateAdditions.swift

Sources/SwiftDriver/Driver/Driver.swift

@@ -787,7 +787,7 @@ extension Driver {
     let execName = try VirtualPath(path: args[0]).basenameWithoutExt
 
     // If we are not run as 'swift' or 'swiftc' or there are no program arguments, always invoke as normal.
-    guard execName == "swift" || execName == "swiftc", args.count > 1 else {
+    guard ["swift.exe", "swiftc.exe", "swift", "swiftc"].contains(execName), args.count > 1 else {
       return (.normal(isRepl: false), args)
     }
 
@@ -797,13 +797,13 @@ extension Driver {
 
     // Check for flags associated with frontend tools.
     if firstArg == "-frontend" {
-      updatedArgs.replaceSubrange(0...1, with: ["swift-frontend"])
+      updatedArgs.replaceSubrange(0...1, with: ["swift-frontend.exe"])
       return (.subcommand("swift-frontend"), updatedArgs)
     }
 
     if firstArg == "-modulewrap" {
-      updatedArgs[0] = "swift-frontend"
-      return (.subcommand("swift-frontend"), updatedArgs)
+      updatedArgs[0] = "swift-frontend.exe"
+      return (.subcommand("swift-frontend.exe"), updatedArgs)
     }
 
     // Only 'swift' supports subcommands.
@@ -824,7 +824,7 @@ extension Driver {
         return (.normal(isRepl: true), updatedArgs)
     }
 
-    let subcommand = "swift-\(firstArg)"
+    let subcommand = "swift-\(firstArg).exe"
 
     updatedArgs.replaceSubrange(0...1, with: [subcommand])
 
@@ -2222,8 +2222,9 @@ extension Driver {
 
       if !fileSystem.exists(path) {
         diagnosticsEngine.emit(.warning_no_such_sdk(sdkPath))
-      } else if isSDKTooOld(sdkPath: path, fileSystem: fileSystem,
-                            diagnosticsEngine: diagnosticsEngine) {
+      } else if false, // (targetTriple?.isDarwin ?? false),
+            isSDKTooOld(sdkPath: path, fileSystem: fileSystem,
+                        diagnosticsEngine: diagnosticsEngine) {
         diagnosticsEngine.emit(.error_sdk_too_old(sdkPath))
         return nil
       }
@@ -2510,7 +2511,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
@@ -2523,7 +2524,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/ExplicitModuleBuilds/ModuleDependencyScanning.swift

@@ -314,6 +314,14 @@ public extension Driver {
 @_spi(Testing) public extension Driver {
   static func getScanLibPath(of toolchain: Toolchain, hostTriple: Triple,
                              env: [String: String]) throws -> AbsolutePath {
+    if hostTriple.isWindows {
+      // no matter if we are in a build tree or an installed tree, the layout is
+      // always: `bin/_InternalSwiftScan.dll`
+      return try getRootPath(of: toolchain, env: env)
+                    .appending(component: "bin")
+                    .appending(component: "_InternalSwiftScan.dll")
+    }
+
     let sharedLibExt: String
     if hostTriple.isMacOSX {
       sharedLibExt = ".dylib"

Sources/SwiftDriver/Jobs/Toolchain+InterpreterSupport.swift

@@ -73,3 +73,16 @@ extension GenericUnixToolchain {
     return envVars
   }
 }
+
+extension WindowsToolchain {
+  public func platformSpecificInterpreterEnvironmentVariables(
+    env: [String : String],
+    parsedOptions: inout ParsedOptions,
+    sdkPath: VirtualPath.Handle?,
+    targetInfo: FrontendTargetInfo) throws -> [String: String] {
+
+    // TODO(compnerd): setting up `Path` is meaningless currently as the lldb
+    // support required for the interpreter mode fails to load the dependencies.
+    return [:]
+  }
+}

Sources/SwiftDriver/Jobs/WindowsToolchain+LinkerSupport.swift

@@ -0,0 +1,130 @@
+//===--------------- WindowsToolchain+LinkerSupport.swift -----------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 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
+
+    if !targetTriple.triple.isEmpty {
+      commandLine.appendFlag("-target")
+      commandLine.appendFlag(targetTriple.triple)
+    }
+
+    switch linkerOutputType {
+    case .staticLibrary:
+      break
+    case .dynamicLibrary:
+      commandLine.appendFlag("-shared")
+    case .executable:
+      break
+    }
+
+    // Select the linker to use.
+    if let arg = parsedOptions.getLastArgument(.useLd) {
+      commandLine.appendFlag("-fuse-ld=\(arg.asSingle)")
+    } else if lto != nil {
+      commandLine.appendFlag("-fuse-ld=lld")
+    }
+
+    switch lto {
+    case .some(.llvmThin):
+      commandLine.appendFlag("-flto=thin")
+    case .some(.llvmFull):
+      commandLine.appendFlag("-flto=full")
+    case .none:
+      break
+    }
+
+    // FIXME(compnerd): render `-Xlinker /DEBUG` or `-Xlinker /DEBUG:DWARF` with
+    // DWARF + lld
+
+    // Rely on `-libc` to correctly identify the MSVC Runtime Library.  We use
+    // `-nostartfiles` as that limits the difference to just the
+    // `-defaultlib:libcmt` which is passed unconditionally with the `clang`
+    // driver rather than the `clang-cl` driver.
+    commandLine.appendFlag("-nostartfiles")
+
+    // TODO(compnerd) investigate the proper way to port this logic over from
+    // the C++ driver.
+
+    // Since Windows has separate libraries per architecture, link against the
+    // architecture specific version of the static library.
+    commandLine.appendFlag(.L)
+    commandLine.appendPath(VirtualPath.lookup(targetInfo.runtimeLibraryImportPaths.last!.path))
+
+    // FIXME(compnerd) figure out how to ensure that the SDK relative path is
+    // the last one
+    commandLine.appendPath(VirtualPath.lookup(targetInfo.runtimeLibraryImportPaths.last!.path)
+                              .appending(component: "swiftrt.obj"))
+
+    commandLine.append(contentsOf: inputs.compactMap { (input: TypedVirtualPath) -> Job.ArgTemplate? in
+      switch input.type {
+      case .object, .llvmBitcode:
+        return .path(input.file)
+      default:
+        return nil
+      }
+    })
+
+    for framework in parsedOptions.arguments(for: .F, .Fsystem) {
+      commandLine.appendFlag(framework.option == .Fsystem ? "-iframework" : "-F")
+      try commandLine.appendPath(VirtualPath(path: framework.argument.asSingle))
+    }
+
+    if let sdkPath = targetInfo.sdkPath?.path {
+      commandLine.appendFlag("-I")
+      commandLine.appendPath(VirtualPath.lookup(sdkPath))
+    }
+
+    if let stdlib = parsedOptions.getLastArgument(.experimentalCxxStdlib) {
+      commandLine.appendFlag("-stdlib=\(stdlib.asSingle)")
+    }
+
+    // FIXME(compnerd) render asan/ubsan runtime link for executables
+
+    if parsedOptions.contains(.profileGenerate) {
+      commandLine.appendFlag("-Xlinker")
+      // FIXME(compnerd) wrap llvm::getInstrProfRuntimeHookVarName()
+      commandLine.appendFlag("-include:__llvm_profile_runtime")
+      commandLine.appendFlag("-lclang_rt.profile")
+    }
+
+    for option in parsedOptions.arguments(for: .Xlinker) {
+      commandLine.appendFlag(.Xlinker)
+      commandLine.appendFlag(option.argument.asSingle)
+    }
+    // TODO(compnerd) is there a separate equivalent to OPT_linker_option_group?
+    try commandLine.appendAllArguments(.XclangLinker, from: &parsedOptions)
+
+    if parsedOptions.contains(.v) {
+      commandLine.appendFlag("-v")
+    }
+
+    commandLine.appendFlag("-o")
+    commandLine.appendPath(outputFile)
+
+    // TODO(compnerd) handle static libraries
+    return try getToolPath(.clang)
+  }
+}

Sources/SwiftDriver/Toolchains/Toolchain.swift

@@ -104,7 +104,7 @@ public protocol Toolchain {
 
 extension Toolchain {
   public var searchPaths: [AbsolutePath] {
-    getEnvSearchPaths(pathString: env["PATH"], currentWorkingDirectory: fileSystem.currentWorkingDirectory)
+    getEnvSearchPaths(pathString: ProcessEnv.path, currentWorkingDirectory: fileSystem.currentWorkingDirectory)
   }
 
   /// Returns the `executablePath`'s directory.
@@ -131,6 +131,9 @@ extension Toolchain {
   private func envVarName(for toolName: String) -> String {
     let lookupName = toolName
       .replacingOccurrences(of: "-", with: "_")
+      // FIXME(compnerd) we should extract the extension for generating the
+      // toolname rather than assuming that we can convert the tool name blindly
+      .replacingOccurrences(of: ".", with: "_")
       .uppercased()
     return "SWIFT_DRIVER_\(lookupName)_EXEC"
   }
@@ -157,7 +160,7 @@ extension Toolchain {
       return path
     } else if let path = try? xcrunFind(executable: executable) {
       return path
-    } else if !["swift-frontend", "swift"].contains(executable),
+    } else if !["swift-frontend.exe", "swift.exe", "swift-frontend", "swift"].contains(executable),
               let parentDirectory = try? getToolPath(.swiftCompiler).parentDirectory,
               parentDirectory != executableDir,
               let path = lookupExecutablePath(filename: executable, searchPaths: [parentDirectory]) {
@@ -166,10 +169,15 @@ extension Toolchain {
       return path
     } else if let path = lookupExecutablePath(filename: executable, searchPaths: searchPaths) {
       return path
-    } else if executable == "swift-frontend" {
+    } else if ["swift-frontend.exe", "swift-frontend"].contains(executable) {
       // Temporary shim: fall back to looking for "swift" before failing.
-      return try lookup(executable: "swift")
+
+      // FIXME(compnerd) this should fallback to `swift`, but only on
+      // non-windows hosts.  To do this we need access to the Driver as we can
+      // check !Driver.hostTriple.isWindows
+      return try lookup(executable: "swift.exe")
     } else if fallbackToExecutableDefaultPath {
+      // TODO(compnerd) correct this for Windows - %SystemDrive%\Developer\Toolchains\....xctoolchain\usr\bin
       return AbsolutePath("/usr/bin/" + executable)
     } else {
       throw ToolchainError.unableToFind(tool: executable)