NVPTX: Register null target streamer

[arsenm]

a74fe4a6a90d60b83c3eb8a55b9fa70dc4963276

llvm/lib/Target/NVPTX/MCTargetDesc/NVPTXMCTargetDesc.cpp

static MCInstPrinter *createNVPTXMCInstPrinter(const Triple &T,
   if (SyntaxVariant == 0)
     return new NVPTXInstPrinter(MAI, MII, MRI);
   return nullptr;
 }
 
 static MCTargetStreamer *createTargetAsmStreamer(MCStreamer &S,
                                                  formatted_raw_ostream &,
                                                  MCInstPrinter *, bool) {
+  return new NVPTXAsmTargetStreamer(S);
+}
+
+static MCTargetStreamer *createNullTargetStreamer(MCStreamer &S) {
   return new NVPTXTargetStreamer(S);
 }
 
 // Force static initialization.
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeNVPTXTargetMC() {
   for (Target *T : {&getTheNVPTXTarget32(), &getTheNVPTXTarget64()}) {
     // Register the MC asm info.
     RegisterMCAsmInfo<NVPTXMCAsmInfo> X(*T);
 
     // Register the MC instruction info.
     TargetRegistry::RegisterMCInstrInfo(*T, createNVPTXMCInstrInfo);
 
     // Register the MC register info.
     TargetRegistry::RegisterMCRegInfo(*T, createNVPTXMCRegisterInfo);
 
     // Register the MC subtarget info.
     TargetRegistry::RegisterMCSubtargetInfo(*T, createNVPTXMCSubtargetInfo);
 
     // Register the MCInstPrinter.
     TargetRegistry::RegisterMCInstPrinter(*T, createNVPTXMCInstPrinter);
 
     // Register the MCTargetStreamer.
     TargetRegistry::RegisterAsmTargetStreamer(*T, createTargetAsmStreamer);
+
+    // Register the MCTargetStreamer.
+    TargetRegistry::RegisterNullTargetStreamer(*T, createNullTargetStreamer);
   }
 }

llvm/lib/Target/NVPTX/MCTargetDesc/NVPTXTargetStreamer.h

public:
   void changeSection(const MCSection *CurSection, MCSection *Section,
                      const MCExpr *SubSection, raw_ostream &OS) override;
   /// Emit the bytes in \p Data into the output.
   ///
   /// This is used to emit bytes in \p Data as sequence of .byte directives.
   void emitRawBytes(StringRef Data) override;
 };
 
+class NVPTXAsmTargetStreamer : public NVPTXTargetStreamer {
+public:
+  NVPTXAsmTargetStreamer(MCStreamer &S);
+  ~NVPTXAsmTargetStreamer() override;
+};
+
 } // end namespace llvm
 
 #endif

llvm/lib/Target/NVPTX/MCTargetDesc/NVPTXTargetStreamer.cpp

 #include "llvm/MC/MCObjectFileInfo.h"
 
 using namespace llvm;
 
 //
 // NVPTXTargetStreamer Implemenation
 //
 NVPTXTargetStreamer::NVPTXTargetStreamer(MCStreamer &S) : MCTargetStreamer(S) {}
-
 NVPTXTargetStreamer::~NVPTXTargetStreamer() = default;
 
+NVPTXAsmTargetStreamer::NVPTXAsmTargetStreamer(MCStreamer &S)
+    : NVPTXTargetStreamer(S) {}
+NVPTXAsmTargetStreamer::~NVPTXAsmTargetStreamer() = default;
+
 void NVPTXTargetStreamer::outputDwarfFileDirectives() {
   for (const std::string &S : DwarfFiles)
     getStreamer().emitRawText(S);
   DwarfFiles.clear();
 }
 
 void NVPTXTargetStreamer::closeLastSection() {
   if (HasSections)

llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp

if (!GlobalsEmitted) {
     GlobalsEmitted = true;
   }
 
   // call doFinalization
   bool ret = AsmPrinter::doFinalization(M);
 
   clearAnnotationCache(&M);
 
-  if (auto *TS = static_cast<NVPTXTargetStreamer *>(
-          OutStreamer->getTargetStreamer())) {
-    // Close the last emitted section
-    if (HasDebugInfo) {
-      TS->closeLastSection();
-      // Emit empty .debug_loc section for better support of the empty files.
-      OutStreamer->emitRawText("\t.section\t.debug_loc\t{\t}");
-    }
+  auto *TS =
+      static_cast<NVPTXTargetStreamer *>(OutStreamer->getTargetStreamer());
 
-    // Output last DWARF .file directives, if any.
-    TS->outputDwarfFileDirectives();
-  }
 
   return ret;
 
   //bool Result = AsmPrinter::doFinalization(M);
   // Instead of calling the parents doFinalization, we may
   // clone parents doFinalization and customize here.
   // Currently, we if NVISA out the EmitGlobals() in
   // parent's doFinalization, which is too intrusive.