diff --git a/Sources/SwiftDriver/CMakeLists.txt b/Sources/SwiftDriver/CMakeLists.txt
index ed22c8bc3..7cb21771c 100644
--- a/Sources/SwiftDriver/CMakeLists.txt
+++ b/Sources/SwiftDriver/CMakeLists.txt
@@ -72,7 +72,6 @@ add_library(SwiftDriver
 
   Jobs/APIDigesterJobs.swift
   Jobs/AutolinkExtractJob.swift
-  Jobs/BackendJob.swift
   Jobs/CommandLineArguments.swift
   Jobs/CompileJob.swift
   Jobs/DarwinToolchain+LinkerSupport.swift
diff --git a/Sources/SwiftDriver/Driver/Driver.swift b/Sources/SwiftDriver/Driver/Driver.swift
index 7f5ba8af1..155b80d1d 100644
--- a/Sources/SwiftDriver/Driver/Driver.swift
+++ b/Sources/SwiftDriver/Driver/Driver.swift
@@ -2424,8 +2424,8 @@ extension Driver {
       linkerOutputType = .executable
     }
 
-    // warn if -embed-bitcode is set and the output type is not an object
-    if parsedOptions.hasArgument(.embedBitcode) && compilerOutputType != .object {
+    // warn if -embed-bitcode is set
+    if parsedOptions.hasArgument(.embedBitcode) {
       diagnosticsEngine.emit(.warn_ignore_embed_bitcode)
       parsedOptions.eraseArgument(.embedBitcode)
     }
@@ -2449,7 +2449,7 @@ extension Diagnostic.Message {
   }
 
   static var warn_ignore_embed_bitcode: Diagnostic.Message {
-    .warning("ignoring -embed-bitcode since no object file is being generated")
+    .warning("'-embed-bitcode' has been deprecated")
   }
 
   static var warn_ignore_embed_bitcode_marker: Diagnostic.Message {
diff --git a/Sources/SwiftDriver/IncrementalCompilation/FirstWaveComputer.swift b/Sources/SwiftDriver/IncrementalCompilation/FirstWaveComputer.swift
index 9983e583e..df09a6dfe 100644
--- a/Sources/SwiftDriver/IncrementalCompilation/FirstWaveComputer.swift
+++ b/Sources/SwiftDriver/IncrementalCompilation/FirstWaveComputer.swift
@@ -54,10 +54,10 @@ extension IncrementalCompilationState {
 
     public func compute(batchJobFormer: inout Driver) throws -> FirstWave {
       return try blockingConcurrentAccessOrMutation {
-        let (initiallySkippedCompileGroups, mandatoryJobsInOrder) =
+        let (initiallySkippedCompileJobs, mandatoryJobsInOrder) =
         try computeInputsAndGroups(batchJobFormer: &batchJobFormer)
         return FirstWave(
-          initiallySkippedCompileGroups: initiallySkippedCompileGroups,
+          initiallySkippedCompileJobs: initiallySkippedCompileJobs,
           mandatoryJobsInOrder: mandatoryJobsInOrder)
       }
     }
@@ -76,33 +76,33 @@ extension IncrementalCompilationState.FirstWaveComputer {
   /// At this stage the graph will have all external dependencies found in the swiftDeps or in the priors
   /// listed in fingerprintExternalDependencies.
   private func computeInputsAndGroups(batchJobFormer: inout Driver)
-  throws -> (initiallySkippedCompileGroups: [TypedVirtualPath: CompileJobGroup],
+  throws -> (initiallySkippedCompileJobs: [TypedVirtualPath: Job],
              mandatoryJobsInOrder: [Job])
   {
-    let compileGroups =
+    let compileJobs =
       Dictionary(uniqueKeysWithValues:
-                  jobsInPhases.compileGroups.map { ($0.primaryInput, $0) })
+                  jobsInPhases.compileJobs.map { ($0.primaryInputs[0], $0) })
     let buildRecord = self.moduleDependencyGraph.buildRecord
     let jobCreatingPch = jobsInPhases.beforeCompiles.first(where: {$0.kind == .generatePCH})
     guard !buildRecord.inputInfos.isEmpty else {
       func everythingIsMandatory()
-        throws -> (initiallySkippedCompileGroups: [TypedVirtualPath: CompileJobGroup],
+        throws -> (initiallySkippedCompileJobs: [TypedVirtualPath: Job],
                    mandatoryJobsInOrder: [Job])
       {
-        let mandatoryCompileGroupsInOrder = self.inputFiles.swiftSourceFiles.compactMap {
-          input -> CompileJobGroup? in
-          compileGroups[input.typedFile]
+        let mandatoryCompileJobsInOrder = self.inputFiles.swiftSourceFiles.compactMap {
+          input -> Job? in
+          compileJobs[input.typedFile]
         }
 
         let mandatoryJobsInOrder = try
         jobsInPhases.beforeCompiles +
         batchJobFormer.formBatchedJobs(
-          mandatoryCompileGroupsInOrder.flatMap {$0.allJobs()},
+          mandatoryCompileJobsInOrder,
           showJobLifecycle: showJobLifecycle,
           jobCreatingPch: jobCreatingPch)
 
         moduleDependencyGraph.setPhase(to: .buildingAfterEachCompilation)
-        return (initiallySkippedCompileGroups: [:],
+        return (initiallySkippedCompileJobs: [:],
                 mandatoryJobsInOrder: mandatoryJobsInOrder)
       }
       return try everythingIsMandatory()
@@ -114,17 +114,17 @@ extension IncrementalCompilationState.FirstWaveComputer {
       moduleDependencyGraph,
       buildRecord)
 
-    let initiallySkippedCompileGroups = compileGroups.filter { initiallySkippedInputs.contains($0.key) }
+    let initiallySkippedCompileJobs = compileJobs.filter { initiallySkippedInputs.contains($0.key) }
 
-    let mandatoryCompileGroupsInOrder = inputFiles.compactMap {
-      input -> CompileJobGroup? in
+    let mandatoryCompileJobsInOrder = inputFiles.compactMap {
+      input -> Job? in
       initiallySkippedInputs.contains(input)
         ? nil
-        : compileGroups[input]
+        : compileJobs[input]
     }
 
     let batchedCompilationJobs = try batchJobFormer.formBatchedJobs(
-      mandatoryCompileGroupsInOrder.flatMap {$0.allJobs()},
+      mandatoryCompileJobsInOrder,
       showJobLifecycle: showJobLifecycle,
       jobCreatingPch: jobCreatingPch)
 
@@ -133,7 +133,7 @@ extension IncrementalCompilationState.FirstWaveComputer {
     // have any dependencies on them.
     let skipAllJobs = batchedCompilationJobs.isEmpty ? !nonVerifyAfterCompileJobsDependOnBeforeCompileJobs() : false
     let mandatoryJobsInOrder = skipAllJobs ? [] : jobsInPhases.beforeCompiles + batchedCompilationJobs
-    return (initiallySkippedCompileGroups: initiallySkippedCompileGroups,
+    return (initiallySkippedCompileJobs: initiallySkippedCompileJobs,
             mandatoryJobsInOrder: mandatoryJobsInOrder)
   }
 
@@ -156,7 +156,7 @@ extension IncrementalCompilationState.FirstWaveComputer {
     _ moduleDependencyGraph: ModuleDependencyGraph,
     _ buildRecord: BuildRecord
   ) -> Set<TypedVirtualPath> {
-    let allGroups = jobsInPhases.compileGroups
+    let allCompileJobs = jobsInPhases.compileJobs
     // Input == source file
     let changedInputs = computeChangedInputs(moduleDependencyGraph, buildRecord)
 
@@ -176,9 +176,9 @@ extension IncrementalCompilationState.FirstWaveComputer {
         reporter.report("Has malformed dependency source; will queue", input)
       }
     }
-    let inputsMissingOutputs = allGroups.compactMap {
+    let inputsMissingOutputs = allCompileJobs.compactMap {
       $0.outputs.contains { (try? !fileSystem.exists($0.file)) ?? true }
-        ? $0.primaryInput
+        ? $0.primaryInputs[0]
         : nil
     }
     if let reporter = reporter {
@@ -257,8 +257,8 @@ extension IncrementalCompilationState.FirstWaveComputer {
     _ moduleDependencyGraph: ModuleDependencyGraph,
     _ outOfDateBuildRecord: BuildRecord
   ) -> [ChangedInput] {
-    jobsInPhases.compileGroups.compactMap { group in
-      let input = group.primaryInput
+    jobsInPhases.compileJobs.compactMap { job in
+      let input = job.primaryInputs[0]
       let modDate = buildRecordInfo.compilationInputModificationDates[input] ?? .distantFuture
       let inputInfo = outOfDateBuildRecord.inputInfos[input.file]
       let previousCompilationStatus = inputInfo?.status ?? .newlyAdded
diff --git a/Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationProtectedState.swift b/Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationProtectedState.swift
index b88e9c6a3..90d482292 100644
--- a/Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationProtectedState.swift
+++ b/Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationProtectedState.swift
@@ -22,7 +22,7 @@ extension IncrementalCompilationState {
     ///
     /// This state is modified during the incremental build. All accesses must
     /// be protected by the confinement queue.
-    fileprivate var skippedCompileGroups: [TypedVirtualPath: CompileJobGroup]
+    fileprivate var skippedCompileJobs: [TypedVirtualPath: Job]
 
     /// Sadly, has to be `var` for formBatchedJobs
     ///
@@ -37,11 +37,11 @@ extension IncrementalCompilationState {
     fileprivate let jobCreatingPch: Job?
     fileprivate let reporter: Reporter?
 
-    init(skippedCompileGroups: [TypedVirtualPath: CompileJobGroup],
+    init(skippedCompileJobs: [TypedVirtualPath: Job],
          _ moduleDependencyGraph: ModuleDependencyGraph,
          _ jobCreatingPch: Job?,
          _ driver: inout Driver) {
-      self.skippedCompileGroups = skippedCompileGroups
+      self.skippedCompileJobs = skippedCompileJobs
       self.moduleDependencyGraph = moduleDependencyGraph
       self.reporter = moduleDependencyGraph.info.reporter
       self.jobCreatingPch = jobCreatingPch
@@ -112,7 +112,7 @@ extension IncrementalCompilationState.ProtectedState {
     }
     self.reporter?.report(
       "Failed to read some dependencies source; compiling everything", input)
-    return TransitivelyInvalidatedSwiftSourceFileSet(skippedCompileGroups.keys.swiftSourceFiles)
+    return TransitivelyInvalidatedSwiftSourceFileSet(skippedCompileJobs.keys.swiftSourceFiles)
   }
 
   /// Find the jobs that now must be run that were not originally known to be needed.
@@ -120,17 +120,17 @@ extension IncrementalCompilationState.ProtectedState {
     for invalidatedInputs: Set<SwiftSourceFile>
   ) throws -> [Job] {
     mutationSafetyPrecondition()
-    return invalidatedInputs.flatMap { input -> [Job] in
-      if let group = skippedCompileGroups.removeValue(forKey: input.typedFile) {
-        let primaryInputs = group.compileJob.primarySwiftSourceFiles
+    return invalidatedInputs.compactMap { input -> Job? in
+      if let job = skippedCompileJobs.removeValue(forKey: input.typedFile) {
+        let primaryInputs = job.primarySwiftSourceFiles
         assert(primaryInputs.count == 1)
         assert(primaryInputs[0] == input)
         self.reporter?.report("Scheduling invalidated", input)
-        return group.allJobs()
+        return job
       }
       else {
         self.reporter?.report("Tried to schedule invalidated input again", input)
-        return []
+        return nil
       }
     }
   }
@@ -141,13 +141,12 @@ extension IncrementalCompilationState.ProtectedState {
 extension IncrementalCompilationState.ProtectedState {
   var skippedCompilationInputs: Set<TypedVirtualPath> {
     accessSafetyPrecondition()
-    return Set(skippedCompileGroups.keys)
+    return Set(skippedCompileJobs.keys)
   }
   public var skippedJobs: [Job] {
     accessSafetyPrecondition()
-    return skippedCompileGroups.values
-      .sorted {$0.primaryInput.file.name < $1.primaryInput.file.name}
-      .flatMap {$0.allJobs()}
+    return skippedCompileJobs.values
+      .sorted {$0.primaryInputs[0].file.name < $1.primaryInputs[0].file.name}
   }
 
   func writeGraph(to path: VirtualPath,
diff --git a/Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState+Extensions.swift b/Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState+Extensions.swift
index 41900876b..9bc923244 100644
--- a/Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState+Extensions.swift
+++ b/Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState+Extensions.swift
@@ -66,7 +66,7 @@ extension IncrementalCompilationState {
     /// The set of compile jobs we can definitely skip given the state of the
     /// incremental dependency graph and the status of the input files for this
     /// incremental build.
-    let initiallySkippedCompileGroups: [TypedVirtualPath: CompileJobGroup]
+    let initiallySkippedCompileJobs: [TypedVirtualPath: Job]
     /// All of the pre-compile or compilation job (groups) known to be required
     /// for the first wave to execute.
     /// The primaries could be other than .swift files, i.e. .sib
@@ -90,12 +90,6 @@ extension Driver {
           because: "it is not compatible with \(compilerMode)"))
       return false
     }
-    guard !parsedOptions.hasArgument(.embedBitcode) else {
-      diagnosticEngine.emit(
-        .remark_incremental_compilation_has_been_disabled(
-          because: "is not currently compatible with embedding LLVM IR bitcode"))
-      return false
-    }
     return true
   }
 }
diff --git a/Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState.swift b/Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState.swift
index fa2cab471..81bb0f6bd 100644
--- a/Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState.swift
+++ b/Sources/SwiftDriver/IncrementalCompilation/IncrementalCompilationState.swift
@@ -71,7 +71,7 @@ public final class IncrementalCompilationState {
     self.info = initialState.graph.info
     self.upToDateInterModuleDependencyGraph = driver.interModuleDependencyGraph
     self.protectedState = ProtectedState(
-      skippedCompileGroups: firstWave.initiallySkippedCompileGroups,
+      skippedCompileJobs: firstWave.initiallySkippedCompileJobs,
       initialState.graph,
       jobsInPhases.allJobs.first(where: {$0.kind == .generatePCH}),
       &driver)
diff --git a/Sources/SwiftDriver/Jobs/BackendJob.swift b/Sources/SwiftDriver/Jobs/BackendJob.swift
deleted file mode 100644
index d160fc954..000000000
--- a/Sources/SwiftDriver/Jobs/BackendJob.swift
+++ /dev/null
@@ -1,81 +0,0 @@
-//===--------------- 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
-//
-//===----------------------------------------------------------------------===//
-
-
-extension Driver {
-  /// Form a backend job.
-  mutating func backendJob(input: TypedVirtualPath,
-                           baseInput: TypedVirtualPath?,
-                           addJobOutputs: ([TypedVirtualPath]) -> Void)
-  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(moduleOutputInfo.name)
-
-    // Add the output file argument if necessary.
-    if let compilerOutputType = compilerOutputType {
-      // If there is no baseInput (singleCompileMode), primary output computation
-      // is not input-specific, therefore it does not matter which input is passed.
-      let output = try computePrimaryOutput(for: baseInput ?? input,
-                                            outputType: compilerOutputType,
-                                            isTopLevel: isTopLevelOutput(type: compilerOutputType))
-      commandLine.appendFlag(.o)
-      commandLine.appendPath(output.file)
-      outputs.append(output)
-    }
-
-    addJobOutputs(outputs)
-
-    return Job(
-      moduleName: moduleOutputInfo.name,
-      kind: .backend,
-      tool: try toolchain.resolvedTool(.swiftCompiler),
-      commandLine: commandLine,
-      displayInputs: inputs,
-      inputs: inputs,
-      primaryInputs: [],
-      outputs: outputs
-    )
-  }
-}
diff --git a/Sources/SwiftDriver/Jobs/DarwinToolchain+LinkerSupport.swift b/Sources/SwiftDriver/Jobs/DarwinToolchain+LinkerSupport.swift
index 6bc071e29..71f60d8ef 100644
--- a/Sources/SwiftDriver/Jobs/DarwinToolchain+LinkerSupport.swift
+++ b/Sources/SwiftDriver/Jobs/DarwinToolchain+LinkerSupport.swift
@@ -214,9 +214,7 @@ extension DarwinToolchain {
       }
     }
 
-    if parsedOptions.contains(.embedBitcode) {
-      commandLine.appendFlag("-fembed-bitcode")
-    } else if parsedOptions.contains(.embedBitcodeMarker) {
+    if parsedOptions.contains(.embedBitcodeMarker) {
       commandLine.appendFlag("-fembed-bitcode=marker")
     }
 
diff --git a/Sources/SwiftDriver/Jobs/Planning.swift b/Sources/SwiftDriver/Jobs/Planning.swift
index 8e75ddaf1..75c93f9cc 100644
--- a/Sources/SwiftDriver/Jobs/Planning.swift
+++ b/Sources/SwiftDriver/Jobs/Planning.swift
@@ -38,53 +38,21 @@ public enum PlanningError: Error, DiagnosticData {
   }
 }
 
-/// When emitting bitcode, if the first compile job is scheduled, the second must be.
-/// So, group them together for incremental build purposes.
-struct CompileJobGroup {
-  let compileJob: Job
-  let backendJob: Job?
-
-  init(compileJob: Job, backendJob: Job?) {
-    assert(compileJob.kind == .compile)
-    assert(compileJob.primaryInputs.count == 1, "must be unbatched")
-    assert(backendJob?.kind ?? .backend == .backend)
-    self.compileJob = compileJob
-    self.backendJob = backendJob
-  }
-
-  func allJobs() -> [Job] {
-    backendJob.map {[compileJob, $0]} ?? [compileJob]
-  }
-
-  /// Any type of file that is `partOfSwiftCompilation`
-  var primaryInput: TypedVirtualPath {
-    compileJob.primaryInputs[0]
-  }
-
-  var primarySwiftSourceInput: SwiftSourceFile? {
-    SwiftSourceFile(ifSource: primaryInput)
-  }
-
-  var outputs: [TypedVirtualPath] {
-    allJobs().flatMap {$0.outputs}
-  }
-}
-
 @_spi(Testing) public struct JobsInPhases {
   /// In WMO mode, also includes the multi-compile & its backends, since there are >1 backend jobs
   let beforeCompiles: [Job]
-  let compileGroups: [CompileJobGroup]
+  let compileJobs: [Job]
   let afterCompiles: [Job]
 
   @_spi(Testing) public var allJobs: [Job] {
     var r = beforeCompiles
-    compileGroups.forEach { r.append(contentsOf: $0.allJobs()) }
+    r.append(contentsOf: compileJobs)
     r.append(contentsOf: afterCompiles)
     return r
   }
 
   @_spi(Testing) public static var none = JobsInPhases(beforeCompiles: [],
-                                                       compileGroups: [],
+                                                       compileJobs: [],
                                                        afterCompiles: [])
 }
 
@@ -169,15 +137,15 @@ extension Driver {
       jobsBeforeCompiles.append(job)
     }
 
-    var  compileJobGroups = [CompileJobGroup]()
-    func addCompileJobGroup(_ group: CompileJobGroup) {
-      compileJobGroups.append(group)
+    var compileJobs = [Job]()
+    func addCompileJob(_ job: Job) {
+      compileJobs.append(job)
     }
 
     // need to buffer these to dodge shared ownership
     var jobsAfterCompiles = [Job]()
-    func addJobAfterCompiles(_ j: Job) {
-      jobsAfterCompiles.append(j)
+    func addJobAfterCompiles(_ job: Job) {
+      jobsAfterCompiles.append(job)
     }
 
     try addPrecompileModuleDependenciesJobs(dependencyGraph: moduleDependencyGraph,
@@ -187,7 +155,7 @@ extension Driver {
     let linkerInputs = try addJobsFeedingLinker(
       addJobBeforeCompiles: addJobBeforeCompiles,
       jobsBeforeCompiles: jobsBeforeCompiles,
-      addCompileJobGroup: addCompileJobGroup,
+      addCompileJob: addCompileJob,
       addJobAfterCompiles: addJobAfterCompiles)
     try addAPIDigesterJobs(addJob: addJobAfterCompiles)
     try addLinkAndPostLinkJobs(linkerInputs: linkerInputs,
@@ -195,7 +163,7 @@ extension Driver {
                                addJob: addJobAfterCompiles)
 
     return JobsInPhases(beforeCompiles: jobsBeforeCompiles,
-                        compileGroups: compileJobGroups,
+                        compileJobs: compileJobs,
                         afterCompiles: jobsAfterCompiles)
   }
 
@@ -277,7 +245,7 @@ extension Driver {
   private mutating func addJobsFeedingLinker(
     addJobBeforeCompiles: (Job) -> Void,
     jobsBeforeCompiles: [Job],
-    addCompileJobGroup: (CompileJobGroup) -> Void,
+    addCompileJob: (Job) -> Void,
     addJobAfterCompiles: (Job) -> Void
   ) throws -> [TypedVirtualPath] {
 
@@ -354,7 +322,7 @@ extension Driver {
     }
 
     try addJobsForPrimaryInputs(
-      addCompileJobGroup: addCompileJobGroup,
+      addCompileJob: addCompileJob,
       addModuleInput: addModuleInput,
       addLinkerInput: addLinkerInput,
       addJobOutputs: addJobOutputs,
@@ -391,37 +359,19 @@ extension Driver {
     guard case .singleCompile = compilerMode,
           inputFiles.contains(where: { $0.type.isPartOfSwiftCompilation })
     else { return nil }
-
-    if parsedOptions.hasArgument(.embedBitcode),
-       inputFiles.allSatisfy({ $0.type.isPartOfSwiftCompilation }) {
-      let compile = try compileJob(primaryInputs: [],
-                                   outputType: .llvmBitcode,
-                                   addJobOutputs: addJobOutputs,
-                                   pchCompileJob: pchCompileJob,
-                                   emitModuleTrace: emitModuleTrace)
-      addJob(compile)
-      let backendJobs = try compile.outputs.compactMap { output in
-        output.type == .llvmBitcode
-          ? try backendJob(input: output, baseInput: nil, addJobOutputs: addJobOutputs)
-          : nil
-      }
-      backendJobs.forEach(addJob)
-      return compile
-    } else {
-      // We can skip the compile jobs if all we want is a module when it's
-      // built separately.
-      let compile = try compileJob(primaryInputs: [],
-                                   outputType: compilerOutputType,
-                                   addJobOutputs: addJobOutputs,
-                                   pchCompileJob: pchCompileJob,
-                                   emitModuleTrace: emitModuleTrace)
-      addJob(compile)
-      return compile
-    }
+    // We can skip the compile jobs if all we want is a module when it's
+    // built separately.
+    let compile = try compileJob(primaryInputs: [],
+                                 outputType: compilerOutputType,
+                                 addJobOutputs: addJobOutputs,
+                                 pchCompileJob: pchCompileJob,
+                                 emitModuleTrace: emitModuleTrace)
+    addJob(compile)
+    return compile
   }
 
   private mutating func addJobsForPrimaryInputs(
-    addCompileJobGroup: (CompileJobGroup) -> Void,
+    addCompileJob: (Job) -> Void,
     addModuleInput: (TypedVirtualPath) -> Void,
     addLinkerInput: (TypedVirtualPath) -> Void,
     addJobOutputs: ([TypedVirtualPath]) -> Void,
@@ -434,7 +384,7 @@ extension Driver {
       // Only emit a loaded module trace from the first frontend job.
       try addJobForPrimaryInput(
         input: input,
-        addCompileJobGroup: addCompileJobGroup,
+        addCompileJob: addCompileJob,
         addModuleInput: addModuleInput,
         addLinkerInput: addLinkerInput,
         addJobOutputs: addJobOutputs,
@@ -445,7 +395,7 @@ extension Driver {
 
   private mutating func addJobForPrimaryInput(
     input: TypedVirtualPath,
-    addCompileJobGroup: (CompileJobGroup) -> Void,
+    addCompileJob: (Job) -> Void,
     addModuleInput: (TypedVirtualPath) -> Void,
     addLinkerInput: (TypedVirtualPath) -> Void,
     addJobOutputs: ([TypedVirtualPath]) -> Void,
@@ -462,11 +412,11 @@ extension Driver {
       // We can skip the compile jobs if all we want is a module when it's
       // built separately.
       let canSkipIfOnlyModule = compilerOutputType == .swiftModule && emitModuleSeparately
-      try createAndAddCompileJobGroup(primaryInput: input,
+      try createAndAddCompileJob(primaryInput: input,
                                       emitModuleTrace: emitModuleTrace,
                                       canSkipIfOnlyModule: canSkipIfOnlyModule,
                                       pchCompileJob: pchCompileJob,
-                                      addCompileJobGroup: addCompileJobGroup,
+                                      addCompileJob: addCompileJob,
                                       addJobOutputs: addJobOutputs)
 
     case .object, .autolink, .llvmBitcode, .tbd:
@@ -495,39 +445,23 @@ extension Driver {
     }
   }
 
-  private mutating func createAndAddCompileJobGroup(
+  private mutating func createAndAddCompileJob(
     primaryInput: TypedVirtualPath,
     emitModuleTrace: Bool,
     canSkipIfOnlyModule: Bool,
     pchCompileJob: Job?,
-    addCompileJobGroup: (CompileJobGroup) -> Void,
+    addCompileJob: (Job) -> Void,
     addJobOutputs: ([TypedVirtualPath]) -> Void
   )  throws {
-    if parsedOptions.hasArgument(.embedBitcode),
-       inputFiles.allSatisfy({ $0.type.isPartOfSwiftCompilation }) {
-      let compile = try compileJob(primaryInputs: [primaryInput],
-                                   outputType: .llvmBitcode,
-                                   addJobOutputs: addJobOutputs,
-                                   pchCompileJob: pchCompileJob,
-                                   emitModuleTrace: emitModuleTrace)
-      let backendJobs = try compile.outputs.compactMap { output in
-        output.type == .llvmBitcode
-          ? try backendJob(input: output, baseInput: primaryInput, addJobOutputs: addJobOutputs)
-          : nil
-      }
-      assert(backendJobs.count <= 1)
-      addCompileJobGroup(CompileJobGroup(compileJob: compile, backendJob: backendJobs.first))
-    } else {
-      // We can skip the compile jobs if all we want is a module when it's
-      // built separately.
-      if parsedOptions.hasArgument(.driverExplicitModuleBuild), canSkipIfOnlyModule { return }
-      let compile = try compileJob(primaryInputs: [primaryInput],
-                                   outputType: compilerOutputType,
-                                   addJobOutputs: addJobOutputs,
-                                   pchCompileJob: pchCompileJob,
-                                   emitModuleTrace: emitModuleTrace)
-      addCompileJobGroup(CompileJobGroup(compileJob: compile, backendJob: nil))
-    }
+    // We can skip the compile jobs if all we want is a module when it's
+    // built separately.
+    if parsedOptions.hasArgument(.driverExplicitModuleBuild), canSkipIfOnlyModule { return }
+    let compile = try compileJob(primaryInputs: [primaryInput],
+                                 outputType: compilerOutputType,
+                                 addJobOutputs: addJobOutputs,
+                                 pchCompileJob: pchCompileJob,
+                                 emitModuleTrace: emitModuleTrace)
+    addCompileJob(compile)
   }
 
   /// Need a merge module job if there are module inputs
@@ -912,9 +846,6 @@ extension Driver {
     let partitions = batchPartitions(
       inputs: inputsInOrder,
       showJobLifecycle: showJobLifecycle)
-    let outputType = parsedOptions.hasArgument(.embedBitcode)
-      ? .llvmBitcode
-      : compilerOutputType
 
     let inputsRequiringModuleTrace = Set(
       compileJobs.filter { $0.outputs.contains {$0.type == .moduleTrace} }
@@ -948,7 +879,7 @@ extension Driver {
       let constituentsEmittedModuleTrace = !inputsRequiringModuleTrace.intersection(primaryInputs).isEmpty
       // no need to add job outputs again
       return try compileJob(primaryInputs: primaryInputs,
-                            outputType: outputType,
+                            outputType: compilerOutputType,
                             addJobOutputs: {_ in },
                             pchCompileJob: jobCreatingPch,
                             emitModuleTrace: constituentsEmittedModuleTrace)
diff --git a/Tests/SwiftDriverTests/SwiftDriverTests.swift b/Tests/SwiftDriverTests/SwiftDriverTests.swift
index 658c57d84..c0bcfd2c1 100644
--- a/Tests/SwiftDriverTests/SwiftDriverTests.swift
+++ b/Tests/SwiftDriverTests/SwiftDriverTests.swift
@@ -6506,32 +6506,6 @@ final class SwiftDriverTests: XCTestCase {
       XCTAssert(plannedJobs[1].commandLine.contains(.flag("-pch-disable-validation")))
     }
 
-    do {
-      var driver = try Driver(args: ["swiftc", "-c", "-embed-bitcode", "-import-objc-header", "TestInputHeader.h", "-pch-output-dir", "/pch", "foo.swift"])
-      let plannedJobs = try driver.planBuild().removingAutolinkExtractJobs()
-      XCTAssertEqual(plannedJobs.count, 3)
-
-      XCTAssertEqual(plannedJobs[0].kind, .generatePCH)
-      XCTAssertEqual(plannedJobs[0].inputs.count, 1)
-      XCTAssertEqual(plannedJobs[0].inputs[0].file, try toPath("TestInputHeader.h"))
-      XCTAssertEqual(plannedJobs[0].inputs[0].type, .objcHeader)
-      XCTAssertEqual(plannedJobs[0].outputs.count, 1)
-      XCTAssertEqual(plannedJobs[0].outputs[0].file.nativePathString(escaped: false), try VirtualPath(path: "/pch/TestInputHeader.pch").nativePathString(escaped: false))
-      XCTAssertEqual(plannedJobs[0].outputs[0].type, .pch)
-      XCTAssert(plannedJobs[0].commandLine.contains(.flag("-frontend")))
-      XCTAssert(plannedJobs[0].commandLine.contains(.flag("-emit-pch")))
-      XCTAssert(plannedJobs[0].commandLine.contains(.flag("-pch-output-dir")))
-      XCTAssert(plannedJobs[0].commandLine.contains(.path(try VirtualPath(path: "/pch"))))
-
-      XCTAssertEqual(plannedJobs[1].kind, .compile)
-      XCTAssertEqual(plannedJobs[1].inputs.count, 2)
-      XCTAssertEqual(plannedJobs[1].inputs[0].file, try toPath("foo.swift"))
-      XCTAssertEqual(plannedJobs[1].outputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[1].outputs[0].file, "foo.bc"))
-
-      XCTAssertEqual(plannedJobs[2].kind, .backend)
-    }
-
     do {
       var driver = try Driver(args: ["swiftc", "-typecheck", "-disable-bridging-pch", "-import-objc-header", "TestInputHeader.h", "-pch-output-dir", "/pch", "foo.swift"])
       let plannedJobs = try driver.planBuild()
@@ -6736,346 +6710,6 @@ final class SwiftDriverTests: XCTestCase {
     }
   }
 
-  func testEmbedBitcode() throws {
-    do {
-      var driver = try Driver(args: ["swiftc", "-embed-bitcode", "embed-bitcode.swift"])
-      let plannedJobs = try driver.planBuild().removingAutolinkExtractJobs()
-      XCTAssertEqual(plannedJobs.count, 3)
-
-      XCTAssertEqual(plannedJobs[0].kind, .compile)
-      XCTAssertEqual(plannedJobs[0].inputs.count, 1)
-      XCTAssertEqual(plannedJobs[0].inputs[0].file, try toPath("embed-bitcode.swift"))
-      XCTAssertEqual(plannedJobs[0].outputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[0].outputs[0].file, "embed-bitcode.bc"))
-
-      XCTAssertEqual(plannedJobs[1].kind, .backend)
-      XCTAssertEqual(plannedJobs[1].inputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[1].inputs[0].file, "embed-bitcode.bc"))
-      XCTAssertEqual(plannedJobs[1].outputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[1].outputs[0].file, "embed-bitcode.o"))
-
-      XCTAssertEqual(plannedJobs[2].kind, .link)
-      XCTAssertEqual(plannedJobs[2].outputs.count, 1)
-      XCTAssertEqual(plannedJobs[2].outputs[0].file, try toPath("embed-bitcode"))
-    }
-
-    do {
-      var driver = try Driver(args: ["swiftc", "-embed-bitcode", "main.swift", "hi.swift"])
-      let plannedJobs = try driver.planBuild().removingAutolinkExtractJobs()
-      XCTAssertEqual(plannedJobs.count, 5)
-
-      XCTAssertEqual(plannedJobs[0].kind, .compile)
-      XCTAssertEqual(plannedJobs[0].inputs.count, 2)
-      XCTAssertEqual(plannedJobs[0].inputs[0].file, try toPath("main.swift"))
-      XCTAssertEqual(plannedJobs[0].inputs[1].file, try toPath("hi.swift"))
-      XCTAssertEqual(plannedJobs[0].outputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[0].outputs[0].file, "main.bc"))
-
-      XCTAssertEqual(plannedJobs[1].kind, .backend)
-      XCTAssertEqual(plannedJobs[1].inputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[1].inputs[0].file, "main.bc"))
-      XCTAssertEqual(plannedJobs[1].outputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[1].outputs[0].file, "main.o"))
-
-      XCTAssertEqual(plannedJobs[2].kind, .compile)
-      XCTAssertEqual(plannedJobs[2].inputs.count, 2)
-      XCTAssertEqual(plannedJobs[2].inputs[0].file, try toPath("main.swift"))
-      XCTAssertEqual(plannedJobs[2].inputs[1].file, try toPath("hi.swift"))
-      XCTAssertEqual(plannedJobs[2].outputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[2].outputs[0].file, "hi.bc"))
-
-      XCTAssertEqual(plannedJobs[3].kind, .backend)
-      XCTAssertEqual(plannedJobs[3].inputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[3].inputs[0].file, "hi.bc"))
-      XCTAssertEqual(plannedJobs[3].outputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[3].outputs[0].file, "hi.o"))
-
-      XCTAssertEqual(plannedJobs[4].kind, .link)
-    }
-
-    do {
-      var driver = try Driver(args: ["swiftc", "-embed-bitcode", "-c", "-emit-module", "embed-bitcode.swift"])
-      let plannedJobs = try driver.planBuild().removingAutolinkExtractJobs()
-      XCTAssertEqual(plannedJobs.count, 3)
-
-      let compileJob = try plannedJobs.findJob(.compile)
-      XCTAssertEqual(compileJob.inputs.count, 1)
-      XCTAssertEqual(compileJob.inputs[0].file, try toPath("embed-bitcode.swift"))
-      XCTAssertEqual(compileJob.outputs.count, 1)
-      XCTAssertTrue(matchTemporary(compileJob.outputs[0].file, "embed-bitcode.bc"))
-
-      let backendJob = try plannedJobs.findJob(.backend)
-      XCTAssertEqual(backendJob.inputs.count, 1)
-      XCTAssertTrue(matchTemporary(backendJob.inputs[0].file, "embed-bitcode.bc"))
-      XCTAssertEqual(backendJob.outputs.count, 1)
-      XCTAssertEqual(backendJob.outputs[0].file, try toPath("embed-bitcode.o"))
-
-      let emitModuleJob = try plannedJobs.findJob(.emitModule)
-      XCTAssertEqual(emitModuleJob.inputs.count, 1)
-      XCTAssertEqual(emitModuleJob.inputs[0].file, try toPath("embed-bitcode.swift"))
-      XCTAssertEqual(emitModuleJob.outputs.count, driver.targetTriple.isDarwin ? 4 : 3)
-      XCTAssertEqual(emitModuleJob.outputs[0].file, try toPath("main.swiftmodule"))
-      XCTAssertEqual(emitModuleJob.outputs[1].file, try toPath("main.swiftdoc"))
-      XCTAssertEqual(emitModuleJob.outputs[2].file, try toPath("main.swiftsourceinfo"))
-      if driver.targetTriple.isDarwin {
-          XCTAssertEqual(emitModuleJob.outputs[3].file, try toPath("main.abi.json"))
-      }
-    }
-
-    do {
-      var driver = try Driver(args: ["swiftc", "-embed-bitcode", "-wmo", "embed-bitcode.swift"])
-      let plannedJobs = try driver.planBuild().removingAutolinkExtractJobs()
-      XCTAssertEqual(plannedJobs.count, 3)
-
-      XCTAssertEqual(plannedJobs[0].kind, .compile)
-      XCTAssertEqual(plannedJobs[0].inputs.count, 1)
-      XCTAssertEqual(plannedJobs[0].inputs[0].file, try toPath("embed-bitcode.swift"))
-      XCTAssertEqual(plannedJobs[0].outputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[0].outputs[0].file, "main.bc"))
-
-      XCTAssertEqual(plannedJobs[1].kind, .backend)
-      XCTAssertEqual(plannedJobs[1].inputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[1].inputs[0].file, "main.bc"))
-      XCTAssertEqual(plannedJobs[1].outputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[1].outputs[0].file, "main.o"))
-
-      XCTAssertEqual(plannedJobs[2].kind, .link)
-      XCTAssertEqual(plannedJobs[2].outputs.count, 1)
-      XCTAssertEqual(plannedJobs[2].outputs[0].file, try toPath("embed-bitcode"))
-    }
-
-    do {
-      var driver = try Driver(args: ["swiftc", "-embed-bitcode", "-c", "-parse-as-library", "-emit-module",  "embed-bitcode.swift", "empty.swift", "-module-name", "ABC"])
-      let plannedJobs = try driver.planBuild().removingAutolinkExtractJobs()
-      XCTAssertEqual(plannedJobs.count, 5)
-
-      XCTAssertEqual(plannedJobs[1].kind, .compile)
-      XCTAssertEqual(plannedJobs[1].outputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[1].outputs[0].file, "embed-bitcode.bc"))
-
-      XCTAssertEqual(plannedJobs[2].kind, .backend)
-      XCTAssertEqual(plannedJobs[2].inputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[2].inputs[0].file, "embed-bitcode.bc"))
-      XCTAssertEqual(plannedJobs[2].outputs.count, 1)
-      XCTAssertEqual(plannedJobs[2].outputs[0].file, try toPath("embed-bitcode.o"))
-
-      XCTAssertEqual(plannedJobs[3].kind, .compile)
-      XCTAssertEqual(plannedJobs[3].outputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[3].outputs[0].file, "empty.bc"))
-
-      XCTAssertEqual(plannedJobs[4].kind, .backend)
-      XCTAssertEqual(plannedJobs[4].inputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[4].inputs[0].file, "empty.bc"))
-
-      XCTAssertEqual(plannedJobs[4].outputs.count, 1)
-      XCTAssertEqual(plannedJobs[4].outputs[0].file, try toPath("empty.o"))
-
-      let emitModuleJob = try plannedJobs.findJob(.emitModule)
-      XCTAssertEqual(emitModuleJob.inputs.count, 2)
-      XCTAssertEqual(emitModuleJob.inputs[0].file, try toPath("embed-bitcode.swift"))
-      XCTAssertEqual(emitModuleJob.inputs[1].file, try toPath("empty.swift"))
-      XCTAssertEqual(emitModuleJob.outputs.count, driver.targetTriple.isDarwin ? 4 : 3)
-      XCTAssertEqual(emitModuleJob.outputs[0].file, try toPath("ABC.swiftmodule"))
-      XCTAssertEqual(emitModuleJob.outputs[1].file, try toPath("ABC.swiftdoc"))
-      XCTAssertEqual(emitModuleJob.outputs[2].file, try toPath("ABC.swiftsourceinfo"))
-      if driver.targetTriple.isDarwin {
-          XCTAssertEqual(emitModuleJob.outputs[3].file, try toPath("ABC.abi.json"))
-      }
-    }
-
-    do {
-      var driver = try Driver(args: ["swiftc", "-embed-bitcode", "-c", "-parse-as-library", "-emit-module", "-whole-module-optimization", "embed-bitcode.swift", "-parse-stdlib", "-module-name", "Swift"])
-      let plannedJobs = try driver.planBuild().removingAutolinkExtractJobs()
-      XCTAssertEqual(plannedJobs.count, 3)
-
-      XCTAssertEqual(plannedJobs[0].kind, .compile)
-      XCTAssertEqual(plannedJobs[0].inputs.count, 1)
-      XCTAssertEqual(plannedJobs[0].inputs[0].file, try toPath("embed-bitcode.swift"))
-      XCTAssertEqual(plannedJobs[0].outputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[0].outputs[0].file, "Swift.bc"))
-
-      XCTAssertEqual(plannedJobs[1].kind, .backend)
-      XCTAssertEqual(plannedJobs[1].inputs.count, 1)
-      XCTAssertTrue(matchTemporary(plannedJobs[1].inputs[0].file, "Swift.bc"))
-      XCTAssertEqual(plannedJobs[1].outputs.count, 1)
-      XCTAssertEqual(plannedJobs[1].outputs[0].file, try toPath("Swift.o"))
-
-      let emitModuleJob = plannedJobs[2]
-      XCTAssertEqual(emitModuleJob.kind, .emitModule)
-      XCTAssertEqual(emitModuleJob.inputs.count, 1)
-      XCTAssertEqual(plannedJobs[0].inputs[0].file, try toPath("embed-bitcode.swift"))
-      XCTAssertEqual(emitModuleJob.outputs.count, driver.targetTriple.isDarwin ? 4 : 3)
-      XCTAssertEqual(1, try emitModuleJob.outputs.filter({try toPath("Swift.swiftmodule") == $0.file}).count)
-      XCTAssertEqual(1, try emitModuleJob.outputs.filter({try toPath("Swift.swiftdoc") == $0.file}).count)
-      XCTAssertEqual(1, try emitModuleJob.outputs.filter({try toPath("Swift.swiftsourceinfo") == $0.file}).count)
-      if driver.targetTriple.isDarwin {
-          XCTAssertEqual(1, try emitModuleJob.outputs.filter({try toPath("Swift.abi.json") == $0.file}).count)
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode", "-emit-module", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode", "-emit-module-path", "a.swiftmodule",  "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode", "-emit-sib", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode", "-emit-sibgen", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode", "-emit-sil", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode", "-emit-silgen", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode", "-emit-ir", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode", "-emit-bc", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode", "-emit-assembly", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode-marker", "-emit-module", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode-marker since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode-marker")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode-marker", "-emit-module-path", "a.swiftmodule",  "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode-marker since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode-marker")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode-marker", "-emit-sib", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode-marker since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode-marker")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode-marker", "-emit-sibgen", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode-marker since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode-marker")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode-marker", "-emit-sil", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode-marker since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode-marker")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode-marker", "-emit-silgen", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode-marker since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode-marker")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode-marker", "-emit-ir", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode-marker since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode-marker")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode-marker", "-emit-bc", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode-marker since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode-marker")))
-      }
-    }
-
-    try assertDriverDiagnostics(args: ["swiftc", "-embed-bitcode-marker", "-emit-assembly", "embed-bitcode.swift"]) { driver, verify in
-      verify.expect(.warning("ignoring -embed-bitcode-marker since no object file is being generated"))
-      let plannedJobs = try driver.planBuild()
-
-      for job in plannedJobs {
-        XCTAssertFalse(job.commandLine.contains(.flag("-embed-bitcode-marker")))
-      }
-    }
-  }
-
   func testCXXInteropOptions() throws {
     do {
       var driver = try Driver(args: ["swiftc", "-cxx-interoperability-mode=swift-5.9", "foo.swift"])
@@ -7733,25 +7367,6 @@ final class SwiftDriverTests: XCTestCase {
       XCTAssertEqual(outputs, [try toPath("a.o"), try toPath("b.o"), try toPath("c.o")])
     }
 
-    do {
-      var driver = try Driver(args: ["swiftc", "-c", "./a.swift", "./b.swift", "./c.swift", "-module-name", "main", "-target", "x86_64-apple-macosx10.9", "-driver-filelist-threshold=0", "-whole-module-optimization", "-num-threads", "1", "-embed-bitcode"],
-                              env: envVars)
-      let plannedJobs = try driver.planBuild()
-      let job = plannedJobs[0]
-      let outputsFlag = job.commandLine.firstIndex(of: .flag("-output-filelist"))!
-      let outputFileListArgument = job.commandLine[job.commandLine.index(after: outputsFlag)]
-      guard case let .path(.fileList(_, outputFileList)) = outputFileListArgument else {
-        return XCTFail("Argument wasn't a filelist")
-      }
-      guard case let .list(outputs) = outputFileList else {
-        return XCTFail("FileList wasn't List")
-      }
-      XCTAssertEqual(outputs.count, 3)
-      XCTAssertTrue(matchTemporary(outputs[0], "a.bc"))
-      XCTAssertTrue(matchTemporary(outputs[1], "b.bc"))
-      XCTAssertTrue(matchTemporary(outputs[2], "c.bc"))
-    }
-
     do {
       var driver = try Driver(args: ["swiftc", "-emit-library", "./a.swift", "./b.swift", "./c.swift", "-module-name", "main", "-target", "x86_64-apple-macosx10.9", "-driver-filelist-threshold=0"],
                               env: envVars)