Merge pull request #878 from compnerd/windows

compnerd · web-flow · commit 6401fbb94538 · 2021-10-20T21:36:09.000-07:00
SwiftDriver: initial (incomplete) windows port
diff --git a/Sources/SwiftDriver/CMakeLists.txt b/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
diff --git a/Sources/SwiftDriver/Driver/Driver.swift b/Sources/SwiftDriver/Driver/Driver.swift
@@ -788,7 +788,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 [executableName("swift"), executableName("swiftc")].contains(execName), args.count > 1 else {
       return (.normal(isRepl: false), args)
     }
 
@@ -798,13 +798,13 @@ extension Driver {
 
     // Check for flags associated with frontend tools.
     if firstArg == "-frontend" {
-      updatedArgs.replaceSubrange(0...1, with: ["swift-frontend"])
-      return (.subcommand("swift-frontend"), updatedArgs)
+      updatedArgs.replaceSubrange(0...1, with: [executableName("swift-frontend")])
+      return (.subcommand(executableName("swift-frontend")), updatedArgs)
     }
 
     if firstArg == "-modulewrap" {
-      updatedArgs[0] = "swift-frontend"
-      return (.subcommand("swift-frontend"), updatedArgs)
+      updatedArgs[0] = executableName("swift-frontend")
+      return (.subcommand(executableName("swift-frontend")), updatedArgs)
     }
 
     // Only 'swift' supports subcommands.
@@ -825,7 +825,7 @@ extension Driver {
         return (.normal(isRepl: true), updatedArgs)
     }
 
-    let subcommand = "swift-\(firstArg)"
+    let subcommand = executableName("swift-\(firstArg)")
 
     updatedArgs.replaceSubrange(0...1, with: [subcommand])
 
@@ -2223,10 +2223,12 @@ extension Driver {
 
       if !fileSystem.exists(path) {
         diagnosticsEngine.emit(.warning_no_such_sdk(sdkPath))
-      } else if isSDKTooOld(sdkPath: path, fileSystem: fileSystem,
-                            diagnosticsEngine: diagnosticsEngine) {
-        diagnosticsEngine.emit(.error_sdk_too_old(sdkPath))
-        return nil
+      } else if !(targetTriple?.isWindows ?? (defaultToolchainType == WindowsToolchain.self)) {
+        if isSDKTooOld(sdkPath: path, fileSystem: fileSystem,
+                       diagnosticsEngine: diagnosticsEngine) {
+          diagnosticsEngine.emit(.error_sdk_too_old(sdkPath))
+          return nil
+        }
       }
 
       return .absolute(path)
@@ -2524,7 +2526,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
@@ -2537,7 +2539,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
diff --git a/Sources/SwiftDriver/Driver/WindowsExtensions.swift b/Sources/SwiftDriver/Driver/WindowsExtensions.swift
@@ -0,0 +1,24 @@
+//===------------- WindowsExtensions.swift - Windows Extensions -----------===//
+//
+// 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 Foundation
+
+internal func executableName(_ name: String) -> String {
+#if os(Windows)
+  if name.suffix(from: name.index(name.endIndex, offsetBy: -4)) == ".exe" {
+    return name
+  }
+  return "\(name).exe"
+#else
+  return name
+#endif
+}
diff --git a/Sources/SwiftDriver/ExplicitModuleBuilds/ModuleDependencyScanning.swift b/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"
diff --git a/Sources/SwiftDriver/Jobs/Toolchain+InterpreterSupport.swift b/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 [:]
+  }
+}
diff --git a/Sources/SwiftDriver/Jobs/WindowsToolchain+LinkerSupport.swift b/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)
+  }
+}
diff --git a/Sources/SwiftDriver/Toolchains/Toolchain.swift b/Sources/SwiftDriver/Toolchains/Toolchain.swift
@@ -104,7 +104,14 @@ public protocol Toolchain {
 
 extension Toolchain {
   public var searchPaths: [AbsolutePath] {
-    getEnvSearchPaths(pathString: env["PATH"], currentWorkingDirectory: fileSystem.currentWorkingDirectory)
+      // Conditionalize this on the build time host because cross-compiling from
+      // a non-Windows host, we would use a Windows toolchain, but would want to
+      // use the platform variable for the path.
+#if os(Windows)
+      return getEnvSearchPaths(pathString: env["Path"], currentWorkingDirectory: fileSystem.currentWorkingDirectory)
+#else
+      return getEnvSearchPaths(pathString: env["PATH"], currentWorkingDirectory: fileSystem.currentWorkingDirectory)
+#endif
   }
 
   /// Returns the `executablePath`'s directory.
@@ -131,6 +138,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 +167,7 @@ extension Toolchain {
       return path
     } else if let path = try? xcrunFind(executable: executable) {
       return path
-    } else if !["swift-frontend", "swift"].contains(executable),
+    } else if ![executableName("swift-frontend"), executableName("swift")].contains(executable),
               let parentDirectory = try? getToolPath(.swiftCompiler).parentDirectory,
               parentDirectory != executableDir,
               let path = lookupExecutablePath(filename: executable, searchPaths: [parentDirectory]) {
@@ -166,11 +176,25 @@ extension Toolchain {
       return path
     } else if let path = lookupExecutablePath(filename: executable, searchPaths: searchPaths) {
       return path
-    } else if executable == "swift-frontend" {
+    } else if executable == executableName("swift-frontend") {
       // Temporary shim: fall back to looking for "swift" before failing.
-      return try lookup(executable: "swift")
+      return try lookup(executable: executableName("swift"))
     } else if fallbackToExecutableDefaultPath {
-      return AbsolutePath("/usr/bin/" + executable)
+      if self is WindowsToolchain {
+        if let DEVELOPER_DIR = env["DEVELOPER_DIR"] {
+          return AbsolutePath(DEVELOPER_DIR)
+                    .appending(component: "Toolchains")
+                    .appending(component: "unknown-Asserts-development.xctoolchain")
+                    .appending(component: "usr")
+                    .appending(component: "bin")
+                    .appending(component: executable)
+        }
+        return try getToolPath(.swiftCompiler)
+                .parentDirectory
+                .appending(component: executable)
+      } else {
+        return AbsolutePath("/usr/bin/" + executable)
+      }
     } else {
       throw ToolchainError.unableToFind(tool: executable)
     }
diff --git a/Sources/SwiftDriver/Toolchains/WindowsToolchain.swift b/Sources/SwiftDriver/Toolchains/WindowsToolchain.swift
diff --git a/Sources/SwiftDriver/Utilities/VirtualPath.swift b/Sources/SwiftDriver/Utilities/VirtualPath.swift
