Merge pull request #148 from DougGregor/more-print-target-info

Use the frontend's -print-target-info more often

Author: DougGregor

Sources/SwiftDriver/Driver/Driver.swift

@@ -77,14 +77,19 @@ public struct Driver {
   /// The executor the driver uses to run jobs.
   public let executor: DriverExecutor
 
+  /// The toolchain to use for resolution.
+  public let toolchain: Toolchain
+
+  /// Information about the target, as reported by the Swift frontend.
+  let frontendTargetInfo: FrontendTargetInfo
+
   /// The target triple.
-  public let targetTriple: Triple
+  public var targetTriple: Triple { frontendTargetInfo.target.triple }
 
   /// The variant target triple.
-  public let targetVariantTriple: Triple?
-
-  /// The toolchain to use for resolution.
-  public let toolchain: Toolchain
+  public var targetVariantTriple: Triple? {
+    frontendTargetInfo.targetVariant?.triple
+  }
 
   /// The kind of driver.
   public let driverKind: DriverKind
@@ -246,12 +251,13 @@ public struct Driver {
     self.optionTable = OptionTable()
     self.parsedOptions = try optionTable.parse(Array(args), for: self.driverKind)
 
-    let explicitTarget = (self.parsedOptions.getLastArgument(.target)?.asSingle)
-      .map {
-        Triple($0, normalizing: true)
-      }
-    (self.toolchain, self.targetTriple) = try Self.computeToolchain(explicitTarget, diagnosticsEngine: diagnosticEngine, env: env, executor: self.executor, fileSystem: fileSystem)
-    self.targetVariantTriple = self.parsedOptions.getLastArgument(.targetVariant).map { Triple($0.asSingle, normalizing: true) }
+    (self.toolchain, self.frontendTargetInfo) = try Self.computeToolchain(
+      &self.parsedOptions, diagnosticsEngine: diagnosticEngine, env: env,
+      executor: self.executor, fileSystem: fileSystem)
+
+    // Local variable to alias the target triple, because self.targetTriple
+    // is not available until the end of this initializer.
+    let targetTriple = self.frontendTargetInfo.target.triple
 
     // Find the Swift compiler executable.
     if let frontendPath = self.parsedOptions.getLastArgument(.driverUseFrontendPath) {
@@ -342,7 +348,8 @@ public struct Driver {
       actualSwiftVersion: try? toolchain.swiftCompilerVersion()
     )
 
-    self.sdkPath = Self.computeSDKPath(&parsedOptions, compilerMode: compilerMode, toolchain: toolchain, fileSystem: fileSystem, diagnosticsEngine: diagnosticEngine, env: env)
+    self.sdkPath = Self.computeSDKPath(&parsedOptions, compilerMode: compilerMode, toolchain: toolchain, targetTriple: targetTriple,
+        fileSystem: fileSystem, diagnosticsEngine: diagnosticEngine, env: env)
 
     self.importedObjCHeader = try Self.computeImportedObjCHeader(&parsedOptions, compilerMode: compilerMode, diagnosticEngine: diagnosticEngine)
     self.bridgingPrecompiledHeader = try Self.computeBridgingPrecompiledHeader(&parsedOptions,
@@ -664,7 +671,7 @@ extension Driver {
 
     if parsedOptions.contains(.driverPrintBindings) {
       for job in jobs {
-        try printBindings(job)
+        printBindings(job)
       }
       return
     }
@@ -728,8 +735,8 @@ extension Driver {
     print(result)
   }
 
-  private func printBindings(_ job: Job) throws {
-    try stdoutStream <<< #"# ""# <<< toolchain.hostTargetTriple().triple
+  private func printBindings(_ job: Job) {
+    stdoutStream <<< #"# ""# <<< targetTriple.triple
     stdoutStream <<< #"" - ""# <<< job.tool.basename
     stdoutStream <<< #"", inputs: ["#
     stdoutStream <<< job.inputs.map { "\"" + $0.file.name + "\"" }.joined(separator: ", ")
@@ -1416,6 +1423,7 @@ extension Driver {
     _ parsedOptions: inout ParsedOptions,
     compilerMode: CompilerMode,
     toolchain: Toolchain,
+    targetTriple: Triple,
     fileSystem: FileSystem,
     diagnosticsEngine: DiagnosticsEngine,
     env: [String: String]
@@ -1427,8 +1435,7 @@ extension Driver {
     } else if let SDKROOT = env["SDKROOT"] {
       sdkPath = SDKROOT
     } else if compilerMode == .immediate || compilerMode == .repl {
-      let triple = try? toolchain.hostTargetTriple()
-      if triple?.isMacOSX == true {
+      if targetTriple.isMacOSX == true {
         // In immediate modes, use the SDK provided by xcrun.
         // This will prefer the SDK alongside the Swift found by "xcrun swift".
         // We don't do this in compilation modes because defaulting to the
@@ -1573,16 +1580,53 @@ extension Driver {
   #endif
 
   static func computeToolchain(
-    _ explicitTarget: Triple?,
+    _ parsedOptions: inout ParsedOptions,
     diagnosticsEngine: DiagnosticsEngine,
     env: [String: String],
     executor: DriverExecutor,
     fileSystem: FileSystem
-  ) throws -> (Toolchain, Triple) {
+  ) throws -> (Toolchain, FrontendTargetInfo) {
+    let explicitTarget = (parsedOptions.getLastArgument(.target)?.asSingle)
+      .map {
+        Triple($0, normalizing: true)
+      }
+    let explicitTargetVariant = (parsedOptions.getLastArgument(.targetVariant)?.asSingle)
+      .map {
+        Triple($0, normalizing: true)
+      }
+
+    // FIXME: Compute these.
+    let sdkPath: VirtualPath? = nil
+    let resourceDirPath: VirtualPath? = nil
+
     let toolchainType = try explicitTarget?.toolchainType(diagnosticsEngine) ??
           defaultToolchainType
     let toolchain = toolchainType.init(env: env, executor: executor, fileSystem: fileSystem)
-    return (toolchain, try explicitTarget ?? toolchain.hostTargetTriple())
+
+    var info = try executor.execute(
+        job: toolchain.printTargetInfoJob(
+          target: explicitTarget, targetVariant: explicitTargetVariant,
+          sdkPath: sdkPath, resourceDirPath: resourceDirPath
+        ),
+        capturingJSONOutputAs: FrontendTargetInfo.self,
+        forceResponseFiles: false,
+        recordedInputModificationDates: [:])
+
+    // Parse the runtime compatibility version. If present, it will override
+    // what is reported by the frontend.
+    if let versionString =
+        parsedOptions.getLastArgument(.runtimeCompatibilityVersion)?.asSingle {
+      if let version = SwiftVersion(string: versionString) {
+        info.target.swiftRuntimeCompatibilityVersion = version
+        info.targetVariant?.swiftRuntimeCompatibilityVersion = version
+      } else {
+        diagnosticsEngine.emit(
+          .error_invalid_arg_value(
+            arg: .runtimeCompatibilityVersion, value: versionString))
+      }
+    }
+
+    return (toolchain, info)
   }
 }
 

Sources/SwiftDriver/Jobs/DarwinToolchain+LinkerSupport.swift

@@ -196,8 +196,7 @@ extension DarwinToolchain {
     outputFile: VirtualPath,
     sdkPath: String?,
     sanitizers: Set<Sanitizer>,
-    targetTriple: Triple,
-    targetVariantTriple: Triple?
+    targetInfo: FrontendTargetInfo
   ) throws -> AbsolutePath {
 
     // FIXME: If we used Clang as a linker instead of going straight to ld,
@@ -209,6 +208,7 @@ extension DarwinToolchain {
     //
     // Note: Normally we'd just add this unconditionally, but it's valid to build
     // Swift and use it as a linker without building compiler_rt.
+    let targetTriple = targetInfo.target.triple
     let darwinPlatformSuffix =
         targetTriple.darwinPlatform!.with(.device)!.libraryNameSuffix
     let compilerRTPath =
@@ -258,7 +258,7 @@ extension DarwinToolchain {
         to: &commandLine,
         parsedOptions: &parsedOptions,
         sdkPath: sdkPath,
-        targetTriple: targetTriple,
+        targetInfo: targetInfo,
         linkerOutputType: linkerOutputType,
         fileSystem: fileSystem
       )
@@ -280,6 +280,7 @@ extension DarwinToolchain {
       parsedOptions: &parsedOptions,
       targetTriple: targetTriple
     )
+    let targetVariantTriple = targetInfo.targetVariant?.triple
     addDeploymentTargetArgs(
       to: &commandLine,
       targetTriple: targetTriple,

Sources/SwiftDriver/Jobs/GenericUnixToolchain+LinkerSupport.swift

@@ -51,9 +51,9 @@ extension GenericUnixToolchain {
     outputFile: VirtualPath,
     sdkPath: String?,
     sanitizers: Set<Sanitizer>,
-    targetTriple: Triple,
-    targetVariantTriple: Triple?
+    targetInfo: FrontendTargetInfo
   ) throws -> AbsolutePath {
+    let targetTriple = targetInfo.target.triple
     switch linkerOutputType {
     case .dynamicLibrary:
       // Same options as an executable, just with '-shared'

Sources/SwiftDriver/Jobs/LinkJob.swift

@@ -47,8 +47,7 @@ extension Driver {
       outputFile: outputFile,
       sdkPath: sdkPath,
       sanitizers: enabledSanitizers,
-      targetTriple: targetTriple,
-      targetVariantTriple: targetVariantTriple
+      targetInfo: frontendTargetInfo
     )
 
     // TODO: some, but not all, linkers support response files.

Sources/SwiftDriver/Jobs/PrintTargetInfoJob.swift

@@ -10,6 +10,77 @@
 //
 //===----------------------------------------------------------------------===//
 
+/// Swift versions are major.minor.
+struct SwiftVersion {
+  var major: Int
+  var minor: Int
+
+  init?(string: String) {
+    let components = string.split(
+          separator: ".", maxSplits: 2, omittingEmptySubsequences: false)
+          .compactMap { Int($0)}
+    guard components.count == 2 else { return nil }
+
+    self.major = components[0]
+    self.minor = components[1]
+  }
+}
+
+extension SwiftVersion: CustomStringConvertible {
+  var description: String { "\(major).\(minor)" }
+}
+
+extension SwiftVersion: Codable {
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    try container.encode(description)
+  }
+
+  init(from decoder: Decoder) throws {
+    let container = try decoder.singleValueContainer()
+    let string = try container.decode(String.self)
+
+    guard let version = SwiftVersion(string: string) else {
+        throw DecodingError.dataCorrupted(.init(
+            codingPath: decoder.codingPath,
+            debugDescription: "Invalid Swift version string \(string)"))
+    }
+
+    self = version
+  }
+}
+
+/// Describes information about the target as provided by the Swift frontend.
+public struct FrontendTargetInfo: Codable {
+  struct Target: Codable {
+    /// The target triple
+    let triple: Triple
+
+    /// The target triple without any version information.
+    let unversionedTriple: Triple
+
+    /// The triple used for module names.
+    let moduleTriple: Triple
+
+    /// The version of the Swift runtime that is present in the runtime
+    /// environment of the target.
+    var swiftRuntimeCompatibilityVersion: SwiftVersion?
+
+    /// Whether the Swift libraries need to be referenced in their system
+    /// location (/usr/lib/swift) via rpath.
+    let librariesRequireRPath: Bool
+  }
+
+  struct Paths: Codable {
+    let runtimeLibraryPaths: [String]
+    let runtimeLibraryImportPaths: [String]
+    let runtimeResourcePath: String
+  }
+
+  var target: Target
+  var targetVariant: Target?
+  let paths: Paths
+}
 
 extension Toolchain {
   func printTargetInfoJob(target: Triple?,