Fix cross-compilation problems

Author: stevapple

Sources/SwiftDriver/Driver/Driver.swift

@@ -373,8 +373,7 @@ public struct Driver {
     Self.validateProfilingArgs(&parsedOptions,
                                fileSystem: fileSystem,
                                workingDirectory: workingDirectory,
-                               diagnosticEngine: diagnosticEngine,
-                               targetTriple: self.frontendTargetInfo.target.triple)
+                               diagnosticEngine: diagnosticEngine)
     Self.validateCompilationConditionArgs(&parsedOptions, diagnosticEngine: diagnosticEngine)
     Self.validateFrameworkSearchPathArgs(&parsedOptions, diagnosticEngine: diagnosticEngine)
     Self.validateCoverageArgs(&parsedOptions, diagnosticsEngine: diagnosticEngine)
@@ -1300,6 +1299,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(
@@ -1659,32 +1663,12 @@ extension Driver {
   static func validateProfilingArgs(_ parsedOptions: inout ParsedOptions,
                                     fileSystem: FileSystem,
                                     workingDirectory: AbsolutePath?,
-                                    diagnosticEngine: DiagnosticsEngine,
-                                    targetTriple: Triple) {
+                                    diagnosticEngine: DiagnosticsEngine) {
     if parsedOptions.hasArgument(.profileGenerate) &&
         parsedOptions.hasArgument(.profileUse) {
       diagnosticEngine.emit(Error.conflictingOptions(.profileGenerate, .profileUse))
     }
 
-    // Windows executables should be profiled with ETW, whose support needs to be
-    // implemented before we can enable the option.
-    if targetTriple.isWindows {
-      if parsedOptions.hasArgument(.profileGenerate) {
-        diagnosticEngine.emit(
-          .error_unsupported_opt_for_target(
-            arg: "-profile-generate",
-            target: targetTriple)
-          )
-      }
-      if parsedOptions.hasArgument(.profileUse) {
-        diagnosticEngine.emit(
-          .error_unsupported_opt_for_target(
-            arg: "-profile-use=",
-            target: targetTriple)
-          )
-      }
-    }
-
     if let profileArgs = parsedOptions.getLastArgument(.profileUse)?.asMultiple,
        let workingDirectory = workingDirectory ?? fileSystem.currentWorkingDirectory {
       for profilingData in profileArgs {

Sources/SwiftDriver/Jobs/Toolchain+LinkerSupport.swift

@@ -119,13 +119,6 @@ extension Toolchain {
     parsedOptions: inout ParsedOptions,
     isShared: Bool
   ) throws -> Bool {
-    // Currently only ASAN is supported on Windows, but clang builds may
-    // include runtime libraries for unsupported sanitizers.  Manually
-    // disable unsupported sanitizers.
-    if targetTriple.isWindows && sanitizer != .address {
-      return false
-    }
-
     let runtimeName = try runtimeLibraryName(
       for: sanitizer,
       targetTriple: targetTriple,

Sources/SwiftDriver/Toolchains/DarwinToolchain.swift

@@ -26,9 +26,6 @@ public final class DarwinToolchain: Toolchain {
   /// The file system to use for any file operations.
   public let fileSystem: FileSystem
 
-  /// The suffix of executable files.
-  public let executableSuffix = ""
-
   /// Doubles as path cache and point for overriding normal lookup
   private var toolPaths = [Tool: AbsolutePath]()
 

Sources/SwiftDriver/Toolchains/GenericUnixToolchain.swift

@@ -21,9 +21,6 @@ public final class GenericUnixToolchain: Toolchain {
   /// The file system to use for queries.
   public let fileSystem: FileSystem
 
-  /// The suffix of executable files.
-  public let executableSuffix = ""
-
   /// Doubles as path cache and point for overriding normal lookup
   private var toolPaths = [Tool: AbsolutePath]()
 

Sources/SwiftDriver/Toolchains/Toolchain.swift

@@ -38,8 +38,6 @@ public protocol Toolchain {
 
   var executor: DriverExecutor { get }
 
-  var executableSuffix: String { get }
-
   /// Retrieve the absolute path to a particular tool.
   func getToolPath(_ tool: Tool) throws -> AbsolutePath
 
@@ -131,7 +129,12 @@ extension Toolchain {
   /// looks in the `executableDir`, `xcrunFind` or in the `searchPaths`.
   /// - Parameter executable: executable to look for [i.e. `swift`].
   func lookup(executable: String) throws -> AbsolutePath {
-    let filename = executable + executableSuffix
+    let filename: String
+    #if os(Windows)
+      filename = "\(executable).exe"
+    #else
+      filename = executable
+    #endif
     if let overrideString = envVar(forExecutable: executable) {
       return try AbsolutePath(validating: overrideString)
     } else if let path = lookupExecutablePath(filename: filename, searchPaths: [executableDir]) {

Sources/SwiftDriver/Toolchains/WindowsToolchain.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 import TSCBasic
+import SwiftOptions
 
 /// Toolchain for Windows.
 public final class WindowsToolchain: Toolchain {
@@ -21,9 +22,6 @@ public final class WindowsToolchain: Toolchain {
   /// The file system to use for queries.
   public let fileSystem: FileSystem
 
-  /// The suffix of executable files.
-  public let executableSuffix = ".exe"
-
   /// Doubles as path cache and point for overriding normal lookup
   private var toolPaths = [Tool: AbsolutePath]()
 
@@ -33,7 +31,7 @@ public final class WindowsToolchain: Toolchain {
     case .arm: return "armv7"
     case .x86: return "i386"
     case nil, .x86_64: return "x86_64"
-    default: fatalError("unknown arch \(triple.archName) on Windows")
+    default: fatalError("unknown arch \(triple.archName) for Windows")
     }
   }
 
@@ -75,9 +73,9 @@ public final class WindowsToolchain: Toolchain {
     case .clang:
       return try lookup(executable: "clang")
     case .swiftAutolinkExtract:
-      fatalError("Trying to look up \"swift-autolink-extract\" on Windows")
+      return try lookup(executable: "swift-autolink-extract")
     case .dsymutil:
-      fatalError("Trying to look up \"dsymutil\" on Windows")
+      return try lookup(executable: "llvm-dsymutil")
     case .lldb:
       return try lookup(executable: "lldb")
     case .dwarfdump:
@@ -105,3 +103,30 @@ public final class WindowsToolchain: Toolchain {
     return "clang_rt.\(sanitizer.libraryName)-\(archName(for: targetTriple)).lib"
   }
 }
+
+extension WindowsToolchain {
+  public func validateArgs(_ parsedOptions: inout ParsedOptions,
+                           targetTriple: Triple,
+                           targetVariantTriple: Triple?,
+                           diagnosticsEngine: DiagnosticsEngine) throws {
+    // Windows executables should be profiled with ETW, whose support needs to be
+    // implemented before we can enable the option.
+    if parsedOptions.hasArgument(.profileGenerate) {
+      throw ToolchainValidationError.argumentNotSupported("-profile-generate")
+    }
+    if parsedOptions.hasArgument(.profileUse) {
+      throw ToolchainValidationError.argumentNotSupported("-profile-use=")
+    }
+  }
+}
+
+public enum ToolchainValidationError: Error, DiagnosticData {
+  case argumentNotSupported(String)
+
+  public var description: String {
+    switch self {
+    case .argumentNotSupported(let argument):
+      return "\(argument) is not supported for Windows"
+    }
+  }
+}