Merge pull request #101 from cltnschlosser/cs_embedBitcode

Support -embed-bitcode and -driver-print-bindings

Author: DougGregor

README.md

@@ -151,7 +151,7 @@ The goal of the new Swift driver is to provide a drop-in replacement for the exi
   * [x] Immediate mode
 * Features
   * [x] Precompiled bridging headers
-  * [ ] Support embedding of bitcode
+  * [x] Support embedding of bitcode
   * [ ] Incremental compilation
   * [x] Parseable output, as used by SwiftPM
   * [x] Response files

Sources/SwiftDriver/Driver/Driver.swift

@@ -150,6 +150,9 @@ public struct Driver {
   /// The name of the Swift module being built.
   public let moduleName: String
 
+  /// Was the module name picked by the driver instead of the user.
+  public let moduleNameIsFallback: Bool
+
   /// The path of the SDK.
   public let sdkPath: String?
 
@@ -322,7 +325,7 @@ public struct Driver {
       Self.computeDebugInfo(&parsedOptions, diagnosticsEngine: diagnosticEngine)
 
     // Determine the module we're building and whether/how the module file itself will be emitted.
-    (self.moduleOutput, self.moduleName) = try Self.computeModuleInfo(
+    (self.moduleOutput, self.moduleName, self.moduleNameIsFallback) = try Self.computeModuleInfo(
       &parsedOptions, compilerOutputType: compilerOutputType, compilerMode: compilerMode, linkerOutputType: linkerOutputType,
       debugInfoLevel: debugInfoLevel, diagnosticsEngine: diagnosticEngine)
 
@@ -651,6 +654,13 @@ extension Driver {
       return
     }
 
+    if parsedOptions.contains(.driverPrintBindings) {
+      for job in jobs {
+        try printBindings(job)
+      }
+      return
+    }
+
     if parsedOptions.contains(.driverPrintGraphviz) {
       var serializer = DOTJobGraphSerializer(jobs: jobs)
       serializer.writeDOT(to: &stdoutStream)
@@ -725,6 +735,21 @@ extension Driver {
     print(result)
   }
 
+  private func printBindings(_ job: Job) throws {
+    try stdoutStream <<< #"# ""# <<< toolchain.hostTargetTriple().triple
+    stdoutStream <<< #"" - ""# <<< job.tool.basename
+    stdoutStream <<< #"", inputs: ["#
+    stdoutStream <<< job.inputs.map { "\"" + $0.file.name + "\"" }.joined(separator: ", ")
+
+    stdoutStream <<< "], output: {"
+
+    stdoutStream <<< job.outputs.map { $0.type.name + ": \"" + $0.file.name + "\"" }.joined(separator: ", ")
+
+    stdoutStream <<< "}"
+    stdoutStream <<< "\n"
+    stdoutStream.flush()
+  }
+
   private func printVersion<S: OutputByteStream>(outputStream: inout S) throws {
     outputStream.write(try Process.checkNonZeroExit(args: toolchain.getToolPath(.swiftCompiler).pathString, "--version"))
     outputStream.flush()
@@ -983,6 +1008,16 @@ extension Driver {
       linkerOutputType = .executable
     }
 
+    // warn if -embed-bitcode is set and the output type is not an object
+    if parsedOptions.hasArgument(.embedBitcode) && compilerOutputType != .object {
+      diagnosticsEngine.emit(.warn_ignore_embed_bitcode)
+      parsedOptions.eraseArgument(.embedBitcode)
+    }
+    if parsedOptions.hasArgument(.embedBitcodeMarker) && compilerOutputType != .object {
+      diagnosticsEngine.emit(.warn_ignore_embed_bitcode_marker)
+      parsedOptions.eraseArgument(.embedBitcodeMarker)
+    }
+
     return (compilerOutputType, linkerOutputType)
   }
 }
@@ -996,6 +1031,14 @@ extension Diagnostic.Message {
       """
     )
   }
+
+  static var warn_ignore_embed_bitcode: Diagnostic.Message {
+    .warning("ignoring -embed-bitcode since no object file is being generated")
+  }
+
+  static var warn_ignore_embed_bitcode_marker: Diagnostic.Message {
+    .warning("ignoring -embed-bitcode-marker since no object file is being generated")
+  }
 }
 
 // Multithreading
@@ -1251,7 +1294,7 @@ extension Driver {
     linkerOutputType: LinkOutputType?,
     debugInfoLevel: DebugInfoLevel?,
     diagnosticsEngine: DiagnosticsEngine
-  ) throws -> (ModuleOutput?, String) {
+  ) throws -> (ModuleOutput?, String, Bool) {
     // Figure out what kind of module we will output.
     enum ModuleOutputKind {
       case topLevel
@@ -1287,6 +1330,7 @@ extension Driver {
 
     // Determine the name of the module.
     var moduleName: String
+    var moduleNameIsFallback = false
     if let arg = parsedOptions.getLastArgument(.moduleName) {
       moduleName = arg.asSingle
     } else if compilerMode == .repl {
@@ -1310,7 +1354,7 @@ extension Driver {
     }
 
     func fallbackOrDiagnose(_ error: Diagnostic.Message) {
-      // FIXME: Current driver notes that this is a "fallback module name".
+      moduleNameIsFallback = true
       if compilerOutputType == nil || maybeBuildingExecutable(&parsedOptions, linkerOutputType: linkerOutputType) {
         moduleName = "main"
       }
@@ -1328,7 +1372,7 @@ extension Driver {
 
     // If we're not emiting a module, we're done.
     if moduleOutputKind == nil {
-      return (nil, moduleName)
+      return (nil, moduleName, moduleNameIsFallback)
     }
 
     // Determine the module file to output.
@@ -1354,9 +1398,9 @@ extension Driver {
 
     switch moduleOutputKind! {
     case .topLevel:
-      return (.topLevel(moduleOutputPath), moduleName)
+      return (.topLevel(moduleOutputPath), moduleName, moduleNameIsFallback)
     case .auxiliary:
-      return (.auxiliary(moduleOutputPath), moduleName)
+      return (.auxiliary(moduleOutputPath), moduleName, moduleNameIsFallback)
     }
   }
 }

Sources/SwiftDriver/Jobs/BackendJob.swift

@@ -0,0 +1,77 @@
+//===--------------- BackendJob.swift - Swift Backend Job -------------===//
+//
+// 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
+
+extension Driver {
+  /// Form a backend job.
+  mutating func backendJob(input: TypedVirtualPath,
+                           allOutputs: inout [TypedVirtualPath]) throws -> Job {
+    var commandLine: [Job.ArgTemplate] = swiftCompilerPrefixArgs.map { Job.ArgTemplate.flag($0) }
+    var inputs = [TypedVirtualPath]()
+    var outputs = [TypedVirtualPath]()
+
+    commandLine.appendFlag("-frontend")
+    addCompileModeOption(outputType: compilerOutputType, commandLine: &commandLine)
+
+    // Add input arguments.
+    commandLine.appendFlag(.primaryFile)
+    commandLine.appendPath(input.file)
+    inputs.append(input)
+
+    commandLine.appendFlag(.embedBitcode)
+
+    // -embed-bitcode only supports a restricted set of flags.
+    commandLine.appendFlag(.target)
+    commandLine.appendFlag(targetTriple.triple)
+
+    // Enable address top-byte ignored in the ARM64 backend.
+    if targetTriple.arch == .aarch64 {
+      commandLine.appendFlag(.Xllvm)
+      commandLine.appendFlag("-aarch64-use-tbi")
+    }
+
+    // Handle the CPU and its preferences.
+    try commandLine.appendLast(.targetCpu, from: &parsedOptions)
+
+    // Enable optimizations, but disable all LLVM-IR-level transformations.
+    try commandLine.appendLast(in: .O, from: &parsedOptions)
+    commandLine.appendFlag(.disableLlvmOptzns)
+
+    try commandLine.appendLast(.parseStdlib, from: &parsedOptions)
+
+    commandLine.appendFlag(.moduleName)
+    commandLine.appendFlag(moduleName)
+
+    // Add the output file argument if necessary.
+    if let compilerOutputType = compilerOutputType {
+      let output = computePrimaryOutput(for: input,
+                                        outputType: compilerOutputType,
+                                        isTopLevel: isTopLevelOutput(type: compilerOutputType))
+      commandLine.appendFlag(.o)
+      commandLine.appendPath(output.file)
+      outputs.append(output)
+    }
+
+    allOutputs += outputs
+
+    return Job(
+      kind: .backend,
+      tool: .absolute(try toolchain.getToolPath(.swiftCompiler)),
+      commandLine: commandLine,
+      displayInputs: inputs,
+      inputs: inputs,
+      outputs: outputs,
+      supportsResponseFiles: true
+    )
+  }
+}

Sources/SwiftDriver/Jobs/CompileJob.swift

@@ -14,7 +14,7 @@ import SwiftOptions
 
 extension Driver {
   /// Add the appropriate compile mode option to the command line for a compile job.
-  private mutating func addCompileModeOption(outputType: FileType?, commandLine: inout [Job.ArgTemplate]) {
+  mutating func addCompileModeOption(outputType: FileType?, commandLine: inout [Job.ArgTemplate]) {
     if let compileOption = outputType?.frontendCompileOption {
       commandLine.appendFlag(compileOption)
     } else {
@@ -26,7 +26,7 @@ extension Driver {
     }
   }
 
-  fileprivate mutating func computePrimaryOutput(for input: TypedVirtualPath, outputType: FileType,
+  mutating func computePrimaryOutput(for input: TypedVirtualPath, outputType: FileType,
                                         isTopLevel: Bool) -> TypedVirtualPath {
     if let path = outputFileMap?.existingOutput(inputFile: input.file, outputType: outputType) {
       return TypedVirtualPath(file: path, type: outputType)
@@ -56,28 +56,31 @@ extension Driver {
     return TypedVirtualPath(file: .relative(.init(baseName.appendingFileTypeExtension(outputType))), type: outputType)
   }
 
-  /// Add the compiler inputs for a frontend compilation job, and return the
-  /// corresponding primary set of outputs.
-  mutating func addCompileInputs(primaryInputs: [TypedVirtualPath],
-                                 inputs: inout [TypedVirtualPath],
-                                 commandLine: inout [Job.ArgTemplate]) -> [TypedVirtualPath] {
-    // Is this compile job top-level
-    let isTopLevel: Bool
-
-    switch compilerOutputType {
+  /// Is this compile job top-level
+  func isTopLevelOutput(type: FileType?) -> Bool {
+    switch type {
     case .assembly, .sil, .raw_sil, .llvmIR, .ast, .jsonDependencies:
-      isTopLevel = true
+      return true
     case .object:
-      isTopLevel = (linkerOutputType == nil)
+      return (linkerOutputType == nil)
     case .swiftModule:
-      isTopLevel = compilerMode.isSingleCompilation && moduleOutput?.isTopLevel ?? false
+      return compilerMode.isSingleCompilation && moduleOutput?.isTopLevel ?? false
     case .swift, .sib, .image, .dSYM, .dependencies, .autolink,
          .swiftDocumentation, .swiftInterface,
          .swiftSourceInfoFile, .raw_sib, .llvmBitcode, .diagnostics,
          .objcHeader, .swiftDeps, .remap, .importedModules, .tbd, .moduleTrace,
          .indexData, .optimizationRecord, .pcm, .pch, nil:
-      isTopLevel = false
+      return false
     }
+  }
+
+  /// Add the compiler inputs for a frontend compilation job, and return the
+  /// corresponding primary set of outputs.
+  mutating func addCompileInputs(primaryInputs: [TypedVirtualPath],
+                                 inputs: inout [TypedVirtualPath],
+                                 outputType: FileType?,
+                                 commandLine: inout [Job.ArgTemplate]) -> [TypedVirtualPath] {
+    let isTopLevel = isTopLevelOutput(type: outputType)
 
     // Collect the set of input files that are part of the Swift compilation.
     let swiftInputFiles: [TypedVirtualPath] = inputFiles.filter { $0.type.isPartOfSwiftCompilation }
@@ -104,16 +107,16 @@ extension Driver {
 
       // If there is a primary output or we are doing multithreaded compiles,
       // add an output for the input.
-      if let compilerOutputType = compilerOutputType,
-        isPrimary || (!usesPrimaryFileInputs && isMultithreaded && compilerOutputType.isAfterLLVM) {
+      if let outputType = outputType,
+        isPrimary || (!usesPrimaryFileInputs && isMultithreaded && outputType.isAfterLLVM) {
         primaryOutputs.append(computePrimaryOutput(for: input,
-                                                   outputType: compilerOutputType,
+                                                   outputType: outputType,
                                                    isTopLevel: isTopLevel))
       }
     }
 
     // When not using primary file inputs or multithreading, add a single output.
-    if let outputType = compilerOutputType,
+    if let outputType = outputType,
       !usesPrimaryFileInputs && !(isMultithreaded && outputType.isAfterLLVM) {
       primaryOutputs.append(computePrimaryOutput(
         for: TypedVirtualPath(file: try! VirtualPath(path: ""),
@@ -133,7 +136,10 @@ extension Driver {
 
     commandLine.appendFlag("-frontend")
     addCompileModeOption(outputType: outputType, commandLine: &commandLine)
-    let primaryOutputs = addCompileInputs(primaryInputs: primaryInputs, inputs: &inputs, commandLine: &commandLine)
+    let primaryOutputs = addCompileInputs(primaryInputs: primaryInputs,
+                                          inputs: &inputs,
+                                          outputType: outputType,
+                                          commandLine: &commandLine)
     outputs += primaryOutputs
     outputs += try addFrontendSupplementaryOutputArguments(commandLine: &commandLine, primaryInputs: primaryInputs)
 

Sources/SwiftDriver/Jobs/Job.swift

@@ -16,6 +16,7 @@ import Foundation
 public struct Job: Codable, Equatable, Hashable {
   public enum Kind: String, Codable {
     case compile
+    case backend
     case mergeModule = "merge-module"
     case link
     case generateDSYM = "generate-dsym"

Sources/SwiftDriver/Jobs/LinkJob.swift

@@ -14,10 +14,9 @@ import TSCBasic
 extension Driver {
 
   /// Compute the output file for an image output.
-  private func outputFileForImage(inputs: [TypedVirtualPath]) -> VirtualPath {
-    // FIXME: The check for __bad__ here, is
-    if inputs.count == 1 && moduleName == "__bad__" && inputs.first!.file != .standardInput {
-      // FIXME: llvm::sys::path::stem(BaseInput);
+  private var outputFileForImage: VirtualPath {
+    if inputFiles.count == 1 && moduleNameIsFallback && inputFiles[0].file != .standardInput {
+      return .relative(RelativePath(inputFiles[0].file.basenameWithoutExt))
     }
 
     let outputName =
@@ -35,7 +34,7 @@ extension Driver {
     if let output = parsedOptions.getLastArgument(.o) {
       outputFile = try VirtualPath(path: output.asSingle)
     } else {
-      outputFile = outputFileForImage(inputs: inputs)
+      outputFile = outputFileForImage
     }
 
     // Defer to the toolchain for platform-specific linking
@@ -58,7 +57,7 @@ extension Driver {
       tool: .absolute(toolPath),
       commandLine: commandLine,
       inputs: inputs,
-      outputs: [.init(file: outputFile, type: .object)]
+      outputs: [.init(file: outputFile, type: .image)]
     )
   }
 }