CodeGen: Add a dwo output file argument to addPassesToEmitFile and hook it up to dwo output.

[pcc]

Summary

Part of PR37466.

Depends on D47051

[echristo]

One inline comment for discussion and LGTM.

-eric

llvm/lib/CodeGen/LLVMTargetMachine.cpp

199

I think the general output stream here at all is pretty awkward, but this isn't necessarily making it worse. Any ideas on where/how to clean this particular one up since you're in there right now? :)

[pcc]

llvm/lib/CodeGen/LLVMTargetMachine.cpp

199

One approach that I was thinking about was to move the MCObjectWriter creation into the TargetMachine client and have it be passed in as a parameter here. We could then also have things like MCAsmWriter and MCNullWriter which would let us drop the FileType enum as well. But for that to work we'd probably want to split the initialization of MCObjectWriter in two to allow the MCAsmBackend to set the MCObjectTargetWriter once it's created, which doesn't seem great but probably the lesser of two evils.

The MCObjectWriter part of this seems easy but getting it to work for the other output formats seemed a little trickier so I decided to leave it for now.

clang/lib/CodeGen/BackendUtil.cpp

bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
   TargetMachine::CodeGenFileType CGFT = getCodeGenFileType(Action);
 
   // Add ObjC ARC final-cleanup optimizations. This is done as part of the
   // "codegen" passes so that it isn't run multiple times when there is
   // inlining happening.
   if (CodeGenOpts.OptimizationLevel > 0)
     CodeGenPasses.add(createObjCARCContractPass());
 
-  if (TM->addPassesToEmitFile(CodeGenPasses, OS, CGFT,
+  if (TM->addPassesToEmitFile(CodeGenPasses, OS, nullptr, CGFT,
                               /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
     Diags.Report(diag::err_fe_unable_to_interface_with_target);
     return false;
   }
 
   return true;
 }
 

llvm/include/llvm/Target/TargetMachine.h

public:
 
   /// Add passes to the specified pass manager to get the specified file
   /// emitted.  Typically this will involve several steps of code generation.
   /// This method should return true if emission of this file type is not
   /// supported, or false on success.
   /// \p MMI is an optional parameter that, if set to non-nullptr,
   /// will be used to set the MachineModuloInfo for this PM.
   virtual bool addPassesToEmitFile(PassManagerBase &, raw_pwrite_stream &,
-                                   CodeGenFileType,
+                                   raw_pwrite_stream *, CodeGenFileType,
                                    bool /*DisableVerify*/ = true,
                                    MachineModuleInfo *MMI = nullptr) {
     return true;
   }
 
   /// Add passes to the specified pass manager to get machine code emitted with
   /// the MCJIT. This method returns true if machine code is not supported. It
   /// fills the MCContext Ctx pointer which can be used to build custom
public:
   /// for generating a pipeline of CodeGen passes.
   virtual TargetPassConfig *createPassConfig(PassManagerBase &PM);
 
   /// Add passes to the specified pass manager to get the specified file
   /// emitted.  Typically this will involve several steps of code generation.
   /// \p MMI is an optional parameter that, if set to non-nullptr,
   /// will be used to set the MachineModuloInfofor this PM.
   bool addPassesToEmitFile(PassManagerBase &PM, raw_pwrite_stream &Out,
-                           CodeGenFileType FileType, bool DisableVerify = true,
+                           raw_pwrite_stream *DwoOut, CodeGenFileType FileType,
+                           bool DisableVerify = true,
                            MachineModuleInfo *MMI = nullptr) override;
 
   /// Add passes to the specified pass manager to get machine code emitted with
   /// the MCJIT. This method returns true if machine code is not supported. It
   /// fills the MCContext Ctx pointer which can be used to build custom
   /// MCStreamer.
   bool addPassesToEmitMC(PassManagerBase &PM, MCContext *&Ctx,
                          raw_pwrite_stream &OS,
                          bool DisableVerify = true) override;
 
   /// Returns true if the target is expected to pass all machine verifier
   /// checks. This is a stopgap measure to fix targets one by one. We will
   /// remove this at some point and always enable the verifier when
   /// EXPENSIVE_CHECKS is enabled.
   virtual bool isMachineVerifierClean() const { return true; }
 
   /// Adds an AsmPrinter pass to the pipeline that prints assembly or
   /// machine code from the MI representation.
   bool addAsmPrinter(PassManagerBase &PM, raw_pwrite_stream &Out,
-                     CodeGenFileType FileTYpe, MCContext &Context);
+                     raw_pwrite_stream *DwoOut, CodeGenFileType FileTYpe,
+                     MCContext &Context);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TARGET_TARGETMACHINE_H

llvm/lib/CodeGen/LLVMTargetMachine.cpp

addPassesToGenerateCode(LLVMTargetMachine *TM, PassManagerBase &PM,
   PassConfig->setInitialized();
   if (!WillCompleteCodeGenPipeline)
     PM.add(createPrintMIRPass(Out));
 
   return &MMI->getContext();
 }
 
 bool LLVMTargetMachine::addAsmPrinter(PassManagerBase &PM,
-    raw_pwrite_stream &Out, CodeGenFileType FileType,
+                                      raw_pwrite_stream &Out,
+                                      raw_pwrite_stream *DwoOut,
+                                      CodeGenFileType FileType,
                                       MCContext &Context) {
   if (Options.MCOptions.MCSaveTempLabels)
     Context.setAllowTemporaryLabels(false);
 
   const MCSubtargetInfo &STI = *getMCSubtargetInfo();
   const MCAsmInfo &MAI = *getMCAsmInfo();
   const MCRegisterInfo &MRI = *getMCRegisterInfo();
   const MCInstrInfo &MII = *getMCInstrInfo();
 
if (!MCE || !MAB)
       return true;
 
     // Don't waste memory on names of temp labels.
     Context.setUseNamesOnTempLabels(false);
 
     Triple T(getTargetTriple().str());
     AsmStreamer.reset(getTarget().createMCObjectStreamer(
         T, Context, std::unique_ptr<MCAsmBackend>(MAB),
-        MAB->createObjectWriter(Out), std::unique_ptr<MCCodeEmitter>(MCE), STI,
-        Options.MCOptions.MCRelaxAll,
+        DwoOut ? MAB->createDwoObjectWriter(Out, *DwoOut)
+               : MAB->createObjectWriter(Out),
+        std::unique_ptr<MCCodeEmitter>(MCE), STI, Options.MCOptions.MCRelaxAll,
         Options.MCOptions.MCIncrementalLinkerCompatible,
         /*DWARFMustBeAtTheEnd*/ true));
     break;
   }
   case CGFT_Null:
     // The Null output is intended for use for performance analysis and testing,
     // not real users.
     AsmStreamer.reset(getTarget().createNullStreamer(Context));
     break;
   }
 
   // Create the AsmPrinter, which takes ownership of AsmStreamer if successful.
   FunctionPass *Printer =
       getTarget().createAsmPrinter(*this, std::move(AsmStreamer));
   if (!Printer)
     return true;
 
   PM.add(Printer);
   return false;
 }
 
 bool LLVMTargetMachine::addPassesToEmitFile(PassManagerBase &PM,
                                             raw_pwrite_stream &Out,
+                                            raw_pwrite_stream *DwoOut,
                                             CodeGenFileType FileType,
                                             bool DisableVerify,
                                             MachineModuleInfo *MMI) {
   // Add common CodeGen passes.
   bool WillCompleteCodeGenPipeline = true;
   MCContext *Context = addPassesToGenerateCode(
       this, PM, DisableVerify, WillCompleteCodeGenPipeline, Out, MMI);
   if (!Context)
     return true;
 
-  if (WillCompleteCodeGenPipeline && addAsmPrinter(PM, Out, FileType, *Context))
+  if (WillCompleteCodeGenPipeline &&
+      addAsmPrinter(PM, Out, DwoOut, FileType, *Context))
     return true;
 
   PM.add(createFreeMachineFunctionPass());
   return false;
 }
 
 /// addPassesToEmitMC - Add passes to the specified pass manager to get
 /// machine code emitted with the MCJIT. This method returns true if machine

llvm/lib/CodeGen/ParallelCG.cpp

 
 using namespace llvm;
 
 static void codegen(Module *M, llvm::raw_pwrite_stream &OS,
                     function_ref<std::unique_ptr<TargetMachine>()> TMFactory,
                     TargetMachine::CodeGenFileType FileType) {
   std::unique_ptr<TargetMachine> TM = TMFactory();
   legacy::PassManager CodeGenPasses;
-  if (TM->addPassesToEmitFile(CodeGenPasses, OS, FileType))
+  if (TM->addPassesToEmitFile(CodeGenPasses, OS, nullptr, FileType))
     report_fatal_error("Failed to setup codegen");
   CodeGenPasses.run(*M);
 }
 
 std::unique_ptr<Module> llvm::splitCodeGen(
     std::unique_ptr<Module> M, ArrayRef<llvm::raw_pwrite_stream *> OSs,
     ArrayRef<llvm::raw_pwrite_stream *> BCOSs,
     const std::function<std::unique_ptr<TargetMachine>()> &TMFactory,

llvm/lib/LTO/LTOBackend.cpp

std::string DwoName = sys::path::filename(Mod.getModuleIdentifier()).str() +
       "-" + std::to_string(Task) + "-";
   size_t index = TempFile.str().rfind("lto-llvm-fission");
   StringRef TempID = TempFile.str().substr(index + 17, 6);
   DwoName += TempID.str() + ".dwo";
   sys::path::append(DwarfFile, DwoName);
   TM->Options.MCOptions.SplitDwarfFile = DwarfFile.str().str();
 
   legacy::PassManager CodeGenPasses;
-  if (TM->addPassesToEmitFile(CodeGenPasses, OS, Conf.CGFileType))
+  if (TM->addPassesToEmitFile(CodeGenPasses, OS, nullptr, Conf.CGFileType))
     report_fatal_error("Failed to setup codegen");
   CodeGenPasses.run(Mod);
 
   if (auto EC = llvm::sys::fs::create_directories(Conf.DwoDir))
     report_fatal_error("Failed to create directory " +
            Conf.DwoDir + ": " + EC.message());
 
   SmallVector<const char*, 5> ExtractArgs, StripArgs;
void codegen(Config &Conf, TargetMachine *TM, AddStreamFn AddStream,
 
   if (!Conf.DwoDir.empty()) {
     codegenWithSplitDwarf(Conf, TM, AddStream, Task, Mod);
     return;
   }
 
   auto Stream = AddStream(Task);
   legacy::PassManager CodeGenPasses;
-  if (TM->addPassesToEmitFile(CodeGenPasses, *Stream->OS, Conf.CGFileType))
+  if (TM->addPassesToEmitFile(CodeGenPasses, *Stream->OS, nullptr,
+                              Conf.CGFileType))
     report_fatal_error("Failed to setup codegen");
   CodeGenPasses.run(Mod);
 }
 
 void splitCodeGen(Config &C, TargetMachine *TM, AddStreamFn AddStream,
                   unsigned ParallelCodeGenParallelismLevel,
                   std::unique_ptr<Module> Mod) {
   ThreadPool CodegenThreadPool(ParallelCodeGenParallelismLevel);

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

// CodeGen
     raw_svector_ostream OS(OutputBuffer);
     legacy::PassManager PM;
 
     // If the bitcode files contain ARC code and were compiled with optimization,
     // the ObjCARCContractPass must be run, so do it unconditionally here.
     PM.add(createObjCARCContractPass());
 
     // Setup the codegen now.
-    if (TM.addPassesToEmitFile(PM, OS, TargetMachine::CGFT_ObjectFile,
+    if (TM.addPassesToEmitFile(PM, OS, nullptr, TargetMachine::CGFT_ObjectFile,
                                /* DisableVerify */ true))
       report_fatal_error("Failed to setup codegen");
 
     // Run codegen now. resulting binary is in OutputBuffer.
     PM.run(TheModule);
   }
   return make_unique<SmallVectorMemoryBuffer>(std::move(OutputBuffer));
 }

llvm/lib/Target/TargetMachineC.cpp

static LLVMBool LLVMTargetMachineEmit(LLVMTargetMachineRef T, LLVMModuleRef M,
   switch (codegen) {
     case LLVMAssemblyFile:
       ft = TargetMachine::CGFT_AssemblyFile;
       break;
     default:
       ft = TargetMachine::CGFT_ObjectFile;
       break;
   }
-  if (TM->addPassesToEmitFile(pass, OS, ft)) {
+  if (TM->addPassesToEmitFile(pass, OS, nullptr, ft)) {
     error = "TargetMachine can't emit a file of this type";
     *ErrorMessage = strdup(error.c_str());
     return true;
   }
 
   pass.run(*Mod);
 
   OS.flush();

llvm/test/CodeGen/X86/dwarf-headers.ll

 ; RUN: llc -dwarf-version=4 -generate-type-units \
 ; RUN:     -filetype=obj -O0 -mtriple=x86_64-unknown-linux-gnu < %s \
 ; RUN:     | llvm-dwarfdump -v - | FileCheck %s --check-prefix=SINGLE-4
 
-; RUN: llc -split-dwarf-file=foo.dwo -dwarf-version=4 -generate-type-units \
+; RUN: llc -split-dwarf-file=foo.dwo -split-dwarf-output=%t.dwo \
+; RUN:     -dwarf-version=4 -generate-type-units \
 ; RUN:     -filetype=obj -O0 -mtriple=x86_64-unknown-linux-gnu < %s \
-; RUN:     | llvm-dwarfdump -v - | FileCheck %s --check-prefix=SPLIT-4
+; RUN:     | llvm-dwarfdump -v - | FileCheck %s --check-prefix=O-4
+; RUN: llvm-dwarfdump -v %t.dwo | FileCheck %s --check-prefix=DWO-4
 
 ; RUN: llc -dwarf-version=5 -generate-type-units \
 ; RUN:     -filetype=obj -O0 -mtriple=x86_64-unknown-linux-gnu < %s \
 ; RUN:     | llvm-dwarfdump -v - | FileCheck %s --check-prefix=SINGLE-5
 
-; RUN: llc -split-dwarf-file=foo.dwo -dwarf-version=5 -generate-type-units \
+; RUN: llc -split-dwarf-file=foo.dwo -split-dwarf-output=%t.dwo \
+; RUN:     -dwarf-version=5 -generate-type-units \
 ; RUN:     -filetype=obj -O0 -mtriple=x86_64-unknown-linux-gnu < %s \
-; RUN:     | llvm-dwarfdump -v - | FileCheck %s --check-prefix=SPLIT-5
+; RUN:     | llvm-dwarfdump -v - | FileCheck %s --check-prefix=O-5
+; RUN: llvm-dwarfdump -v %t.dwo | FileCheck %s --check-prefix=DWO-5
 
 ; Looking for DWARF headers to be generated correctly.
 ; There are 7 variants: v4 CU, v4 TU, v5 (normal/skeleton/split) CU,
 ; v5 (normal/split) TU.  The v5 CU variants and TU variants differ
 ; only in the type-unit code.
 ; (v2 thru v4 CUs are all the same, and TUs were invented in v4,
 ; so we don't bother checking older versions.)
 

 ; SINGLE-4: 0x0000000b: DW_TAG_compile_unit
 ;
 ; SINGLE-4: .debug_types contents:
 ; SINGLE-4: 0x00000000: Type Unit: {{.*}} version = 0x0004 abbr_offset
 ; SINGLE-4: 0x00000017: DW_TAG_type_unit
 
 ; Verify the v4 split headers.
 ;
-; SPLIT-4: .debug_info contents:
-; SPLIT-4: 0x00000000: Compile Unit: {{.*}} version = 0x0004 abbr_offset
-; SPLIT-4: 0x0000000b: DW_TAG_compile_unit
-;
-; SPLIT-4: .debug_info.dwo contents:
-; SPLIT-4: 0x00000000: Compile Unit: {{.*}} version = 0x0004 abbr_offset
-; SPLIT-4: 0x0000000b: DW_TAG_compile_unit
-;
-; SPLIT-4: .debug_types.dwo contents:
-; SPLIT-4: 0x00000000: Type Unit: {{.*}} version = 0x0004 abbr_offset
-; SPLIT-4: 0x00000017: DW_TAG_type_unit
+; O-4: .debug_info contents:
+; O-4: 0x00000000: Compile Unit: {{.*}} version = 0x0004 abbr_offset
+; O-4: 0x0000000b: DW_TAG_compile_unit
+;
+; DWO-4: .debug_info.dwo contents:
+; DWO-4: 0x00000000: Compile Unit: {{.*}} version = 0x0004 abbr_offset
+; DWO-4: 0x0000000b: DW_TAG_compile_unit
+;
+; DWO-4: .debug_types.dwo contents:
+; DWO-4: 0x00000000: Type Unit: {{.*}} version = 0x0004 abbr_offset
+; DWO-4: 0x00000017: DW_TAG_type_unit
 
 ; Verify the v5 non-split headers.
 ;
 ; SINGLE-5: .debug_info contents:
 ; SINGLE-5: 0x00000000: Compile Unit: {{.*}} version = 0x0005 unit_type = DW_UT_compile abbr_offset
 ; SINGLE-5: 0x0000000c: DW_TAG_compile_unit
 ;
 ; FIXME: V5 wants type units in .debug_info not .debug_types.
 ; SINGLE-5: .debug_types contents:
 ; SINGLE-5: 0x00000000: Type Unit: {{.*}} version = 0x0005 unit_type = DW_UT_type abbr_offset
 ; SINGLE-5: 0x00000018: DW_TAG_type_unit
 
 ; Verify the v5 split headers.
 ;
-; SPLIT-5: .debug_info contents:
-; SPLIT-5: 0x00000000: Compile Unit: {{.*}} version = 0x0005 unit_type = DW_UT_skeleton abbr_offset
-; SPLIT-5: 0x0000000c: DW_TAG_compile_unit
-;
-; SPLIT-5: .debug_info.dwo contents:
-; SPLIT-5: 0x00000000: Compile Unit: {{.*}} version = 0x0005 unit_type = DW_UT_split_compile abbr_offset
-; SPLIT-5: 0x0000000c: DW_TAG_compile_unit
+; O-5: .debug_info contents:
+; O-5: 0x00000000: Compile Unit: {{.*}} version = 0x0005 unit_type = DW_UT_skeleton abbr_offset
+; O-5: 0x0000000c: DW_TAG_compile_unit
+;
+; DWO-5: .debug_info.dwo contents:
+; DWO-5: 0x00000000: Compile Unit: {{.*}} version = 0x0005 unit_type = DW_UT_split_compile abbr_offset
+; DWO-5: 0x0000000c: DW_TAG_compile_unit
 ;
 ; FIXME: V5 wants type units in .debug_info.dwo not .debug_types.dwo.
-; SPLIT-5: .debug_types.dwo contents:
-; SPLIT-5: 0x00000000: Type Unit: {{.*}} version = 0x0005 unit_type = DW_UT_split_type abbr_offset
-; SPLIT-5: 0x00000018: DW_TAG_type_unit
+; DWO-5: .debug_types.dwo contents:
+; DWO-5: 0x00000000: Type Unit: {{.*}} version = 0x0005 unit_type = DW_UT_split_type abbr_offset
+; DWO-5: 0x00000018: DW_TAG_type_unit
 
 
 ; ModuleID = 't.cpp'
 source_filename = "t.cpp"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %struct.S = type { i32 }

llvm/test/CodeGen/X86/dwarf-split-line-1.ll

 ; Verify that split type units with no source locations don't have a
 ; DW_AT_stmt_list attribute, and the .debug_line.dwo section is suppressed.
 
-; RUN: llc -split-dwarf-file=foo.dwo -dwarf-version=5 -generate-type-units \
-; RUN:     -filetype=obj -O0 -mtriple=x86_64-unknown-linux-gnu < %s \
-; RUN:     | llvm-dwarfdump -v - | FileCheck %s
+; RUN: llc -split-dwarf-file=foo.dwo -split-dwarf-output=%t.dwo \
+; RUN:     -dwarf-version=5 -generate-type-units \
+; RUN:     -filetype=obj -O0 -mtriple=x86_64-unknown-linux-gnu < %s
+; RUN: llvm-dwarfdump -v %t.dwo | FileCheck %s
 
 ; FIXME: V5 wants type units in .debug_info.dwo not .debug_types.dwo.
 ; CHECK-NOT: .debug_line.dwo
 ; CHECK: .debug_types.dwo contents:
 ; CHECK: 0x00000000: Type Unit: {{.*}} version = 0x0005 unit_type = DW_UT_split_type abbr_offset
 ; CHECK: 0x00000018: DW_TAG_type_unit
 ; CHECK-NOT: DW_AT_stmt_list
 ; CHECK-NOT: DW_AT_decl_file

llvm/test/CodeGen/X86/dwarf-split-line-2.ll

 ; Verify that if we have two split type units, one with source locations and
 ; one without, the one without locations doesn't have a DW_AT_stmt_list
 ; attribute, but the other one does and the .debug_line.dwo section is present.
 
-; RUN: llc -split-dwarf-file=foo.dwo -dwarf-version=5 -generate-type-units \
-; RUN:     -filetype=obj -O0 -mtriple=x86_64-unknown-linux-gnu < %s \
-; RUN:     | llvm-dwarfdump -v - | FileCheck %s
+; RUN: llc -split-dwarf-file=foo.dwo -split-dwarf-output=%t.dwo \
+; RUN:     -dwarf-version=5 -generate-type-units \
+; RUN:     -filetype=obj -O0 -mtriple=x86_64-unknown-linux-gnu < %s
+; RUN: llvm-dwarfdump -v %t.dwo | FileCheck %s
 
 ; Currently the no-source-location type comes out first.
 ; FIXME: V5 wants type units in .debug_info.dwo not .debug_types.dwo.
 ; CHECK: .debug_types.dwo contents:
 ; CHECK: 0x00000000: Type Unit: {{.*}} name = 'S'
 ; CHECK-SAME: (next unit at [[TU2:0x[0-9a-f]+]])
 ; CHECK: DW_TAG_type_unit
 ; CHECK-NOT: DW_AT_stmt_list

llvm/tools/llc/llc.cpp

 InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));
 
 static cl::opt<std::string>
 InputLanguage("x", cl::desc("Input language ('ir' or 'mir')"));
 
 static cl::opt<std::string>
 OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"));
 
+static cl::opt<std::string>
+    SplitDwarfOutputFile("split-dwarf-output",
+                         cl::desc(".dwo output filename"),
+                         cl::value_desc("filename"));
+
 static cl::opt<unsigned>
 TimeCompilations("time-compilations", cl::Hidden, cl::init(1u),
                  cl::value_desc("N"),
                  cl::desc("Repeat compilation N times for timing"));
 
 static cl::opt<bool>
 NoIntegratedAssembler("no-integrated-as", cl::Hidden,
                       cl::desc("Disable integrated assembler"));
static int compileModule(char **argv, LLVMContext &Context) {
   if (FloatABIForCalls != FloatABI::Default)
     Options.FloatABIType = FloatABIForCalls;
 
   // Figure out where we are going to send the output.
   std::unique_ptr<ToolOutputFile> Out =
       GetOutputStream(TheTarget->getName(), TheTriple.getOS(), argv[0]);
   if (!Out) return 1;
 
+  std::unique_ptr<ToolOutputFile> DwoOut;
+  if (!SplitDwarfOutputFile.empty()) {
+    std::error_code EC;
+    DwoOut = llvm::make_unique<ToolOutputFile>(SplitDwarfOutputFile, EC,
+                                               sys::fs::F_None);
+    if (EC) {
+      errs() << EC.message() << '\n';
+      return 1;
+    }
+  }
+
   // Build up all of the passes that we want to do to the module.
   legacy::PassManager PM;
 
   // Add an appropriate TargetLibraryInfo pass for the module's triple.
   TargetLibraryInfoImpl TLII(Triple(M->getTargetTriple()));
 
   // The -disable-simplify-libcalls flag actually disables all builtin optzns.
   if (DisableSimplifyLibCalls)
if (!RunPassNames->empty()) {
       TPC.printAndVerify("");
       for (const std::string &RunPassName : *RunPassNames) {
         if (addPass(PM, argv0, RunPassName, TPC))
           return 1;
       }
       TPC.setInitialized();
       PM.add(createPrintMIRPass(*OS));
       PM.add(createFreeMachineFunctionPass());
-    } else if (Target->addPassesToEmitFile(PM, *OS, FileType, NoVerify, MMI)) {
+    } else if (Target->addPassesToEmitFile(PM, *OS,
+                                           DwoOut ? &DwoOut->os() : nullptr,
+                                           FileType, NoVerify, MMI)) {
       errs() << argv0 << ": target does not support generation of this"
              << " file type!\n";
       return 1;
     }
 
     if (MIR) {
       assert(MMI && "Forgot to create MMI?");
       if (MIR->parseMachineFunctions(*M, *MMI))
if (RelaxAll.getNumOccurrences() > 0 &&
 
     if (BOS) {
       Out->os() << Buffer;
     }
   }
 
   // Declare success.
   Out->keep();
+  if (DwoOut)
+    DwoOut->keep();
 
   return 0;
 }

llvm/tools/llvm-exegesis/lib/Assembler.cpp

void assembleToStream(std::unique_ptr<llvm::LLVMTargetMachine> TM,
   // - machineverifier: checks that the MachineFunction is well formed.
   // - prologepilog: saves and restore callee saved registers.
   for (const char *PassName : {"machineverifier", "prologepilog"})
     if (addPass(PM, PassName, *TPC))
       llvm::report_fatal_error("Unable to add a mandatory pass");
   TPC->setInitialized();
 
   // AsmPrinter is responsible for generating the assembly into AsmBuffer.
-  if (TM->addAsmPrinter(PM, AsmStream, llvm::TargetMachine::CGFT_ObjectFile,
-                        MCContext))
+  if (TM->addAsmPrinter(PM, AsmStream, nullptr,
+                        llvm::TargetMachine::CGFT_ObjectFile, MCContext))
     llvm::report_fatal_error("Cannot add AsmPrinter passes");
 
   PM.run(*Module); // Run all the passes
 }
 
 llvm::object::OwningBinary<llvm::object::ObjectFile>
 getObjectFromBuffer(llvm::StringRef InputData) {
   // Storing the generated assembly into a MemoryBuffer that owns the memory.

llvm/tools/llvm-isel-fuzzer/llvm-isel-fuzzer.cpp

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
   M->setTargetTriple(TM->getTargetTriple().normalize());
   M->setDataLayout(TM->createDataLayout());
 
   // Build up a PM to do instruction selection.
   legacy::PassManager PM;
   TargetLibraryInfoImpl TLII(TM->getTargetTriple());
   PM.add(new TargetLibraryInfoWrapperPass(TLII));
   raw_null_ostream OS;
-  TM->addPassesToEmitFile(PM, OS, TargetMachine::CGFT_Null);
+  TM->addPassesToEmitFile(PM, OS, nullptr, TargetMachine::CGFT_Null);
   PM.run(*M);
 
   return 0;
 }
 
 static void handleLLVMFatalError(void *, const std::string &Message, bool) {
   // TODO: Would it be better to call into the fuzzer internals directly?
   dbgs() << "LLVM ERROR: " << Message << "\n"

polly/lib/CodeGen/PPCGCodeGeneration.cpp

std::unique_ptr<TargetMachine> TargetM(GPUTarget->createTargetMachine(
       GPUTriple.getTriple(), subtarget, "", Options, Optional<Reloc::Model>()));
 
   SmallString<0> ASMString;
   raw_svector_ostream ASMStream(ASMString);
   llvm::legacy::PassManager PM;
 
   PM.add(createTargetTransformInfoWrapperPass(TargetM->getTargetIRAnalysis()));
 
-  if (TargetM->addPassesToEmitFile(
-          PM, ASMStream, TargetMachine::CGFT_AssemblyFile, true /* verify */)) {
+  if (TargetM->addPassesToEmitFile(PM, ASMStream, nullptr,
+                                   TargetMachine::CGFT_AssemblyFile,
+                                   true /* verify */)) {
     errs() << "The target does not support generation of this file type!\n";
     return "";
   }
 
   PM.run(*GPUModule);
 
   return ASMStream.str();
 }