AMDGPU: Don't use TargetStreamer if it has not been initialized

[tstellar]

Why is this necessary? Do other targets need to do ths?

[javed.absar]

lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp

1232

Instead of the numerous lambda functions making the code reading complicated, Could one make it neater like this ?

234: if (AMDGPUTargetStreamer *S =getTargetStreamer() )
235: Streamer->EmitGPUSymbolType(...)
236

AMDGPUTargetStreamer *getAMDGPUTargetStreamer( ) {

if (!OutStreamer)
   return nullptr;
....

}

[arsenm]

I also don't understand why this would be necessary. How can the streamer not be available?

[kzhuravl]

In D38959#899086, @arsenm wrote:

I also don't understand why this would be necessary. How can the streamer not be available?

It seems like the TargetStreamer is not created if -emit-codegen-only option is passed to clang cc1. I have hit it last week here:
http://green.lab.llvm.org/green/job/clang-stage1-cmake-RA-incremental/43381/

I haven't had a chance to look at other targets yet. But will when I get a chance.

[arsenm]

That seems like a clang bug? I don't understand what the option is for, but isn't there some null streamer it's supposed to use?

lib/Target/AMDGPU/AMDGPUAsmPrinter.h

private:
 
   AMDGPU::HSAMD::Kernel::CodeProps::Metadata getHSACodeProps(
       const MachineFunction &MF,
       const SIProgramInfo &ProgramInfo) const;
   AMDGPU::HSAMD::Kernel::DebugProps::Metadata getHSADebugProps(
       const MachineFunction &MF,
       const SIProgramInfo &ProgramInfo) const;
 
+  void useTargetStreamer(
+      function_ref<void(AMDGPUTargetStreamer *TargetStreamer)> Func);
+
   /// \brief Emit register usage information so that the GPU driver
   /// can correctly setup the GPU state.
   void EmitProgramInfoR600(const MachineFunction &MF);
   void EmitProgramInfoSI(const MachineFunction &MF,
                          const SIProgramInfo &KernelInfo);
   void EmitPALMetadata(const MachineFunction &MF,
                        const SIProgramInfo &KernelInfo);
   void emitCommonFunctionComments(uint32_t NumVGPR,
                                   uint32_t NumSGPR,
                                   uint32_t ScratchSize,
                                   uint64_t CodeSize);
 
 public:
   explicit AMDGPUAsmPrinter(TargetMachine &TM,
                             std::unique_ptr<MCStreamer> Streamer);
 
   StringRef getPassName() const override;
 
   const MCSubtargetInfo* getSTI() const;
 
-  AMDGPUTargetStreamer* getTargetStreamer() const;
-
   bool doFinalization(Module &M) override;
   bool runOnMachineFunction(MachineFunction &MF) override;
 
   /// \brief Wrapper for MCInstLowering.lowerOperand() for the tblgen'erated
   /// pseudo lowering.
   bool lowerOperand(const MachineOperand &MO, MCOperand &MCOp) const;
 
   /// \brief Lower the specified LLVM Constant to an MCExpr.

lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp

 StringRef AMDGPUAsmPrinter::getPassName() const {
   return "AMDGPU Assembly Printer";
 }
 
 const MCSubtargetInfo* AMDGPUAsmPrinter::getSTI() const {
   return TM.getMCSubtargetInfo();
 }
 
-AMDGPUTargetStreamer* AMDGPUAsmPrinter::getTargetStreamer() const {
-  if (!OutStreamer)
-    return nullptr;
-  return static_cast<AMDGPUTargetStreamer*>(OutStreamer->getTargetStreamer());
-}
-
 void AMDGPUAsmPrinter::EmitStartOfAsmFile(Module &M) {
   if (TM.getTargetTriple().getArch() != Triple::amdgcn)
     return;
 
   if (TM.getTargetTriple().getOS() != Triple::AMDHSA &&
       TM.getTargetTriple().getOS() != Triple::AMDPAL)
     return;
 
   if (TM.getTargetTriple().getOS() == Triple::AMDHSA)
     HSAMetadataStream.begin(M);
 
   if (TM.getTargetTriple().getOS() == Triple::AMDPAL)
     readPALMetadata(M);
 
   // Deprecated notes are not emitted for code object v3.
   if (IsaInfo::hasCodeObjectV3(getSTI()->getFeatureBits()))
     return;
 
   // HSA emits NT_AMDGPU_HSA_CODE_OBJECT_VERSION for code objects v2.
-  if (TM.getTargetTriple().getOS() == Triple::AMDHSA)
-    getTargetStreamer()->EmitDirectiveHSACodeObjectVersion(2, 1);
+  if (TM.getTargetTriple().getOS() == Triple::AMDHSA) {
+    useTargetStreamer(
+        [&](AMDGPUTargetStreamer *TargetStreamer) {
+          TargetStreamer->EmitDirectiveHSACodeObjectVersion(2, 1);
+        }
+    );
+  }
 
   // HSA and PAL emit NT_AMDGPU_HSA_ISA for code objects v2.
   IsaInfo::IsaVersion ISA = IsaInfo::getIsaVersion(getSTI()->getFeatureBits());
-  getTargetStreamer()->EmitDirectiveHSACodeObjectISA(
+  useTargetStreamer(
+      [&](AMDGPUTargetStreamer *TargetStreamer) {
+        TargetStreamer->EmitDirectiveHSACodeObjectISA(
             ISA.Major, ISA.Minor, ISA.Stepping, "AMD", "AMDGPU");
       }
+  );
+}
 
 void AMDGPUAsmPrinter::EmitEndOfAsmFile(Module &M) {
   if (TM.getTargetTriple().getArch() != Triple::amdgcn)
     return;
 
-  // Following code requires TargetStreamer to be present.
-  if (!getTargetStreamer())
-    return;
-
   // Emit ISA Version (NT_AMD_AMDGPU_ISA).
   std::string ISAVersionString;
   raw_string_ostream ISAVersionStream(ISAVersionString);
   IsaInfo::streamIsaVersion(getSTI(), ISAVersionStream);
-  getTargetStreamer()->EmitISAVersion(ISAVersionStream.str());
+  useTargetStreamer(
+      [&](AMDGPUTargetStreamer *TargetStreamer) {
+        TargetStreamer->EmitISAVersion(ISAVersionStream.str());
+      }
+  );
 
   // Emit HSA Metadata (NT_AMD_AMDGPU_HSA_METADATA).
   if (TM.getTargetTriple().getOS() == Triple::AMDHSA) {
     HSAMetadataStream.end();
-    getTargetStreamer()->EmitHSAMetadata(HSAMetadataStream.getHSAMetadata());
+    useTargetStreamer(
+        [&](AMDGPUTargetStreamer *TargetStreamer) {
+          TargetStreamer->EmitHSAMetadata(HSAMetadataStream.getHSAMetadata());
+        }
+    );
   }
 
   // Emit PAL Metadata (NT_AMD_AMDGPU_PAL_METADATA).
   if (TM.getTargetTriple().getOS() == Triple::AMDPAL) {
     // Copy the PAL metadata from the map where we collected it into a vector,
     // then write it as a .note.
     PALMD::Metadata PALMetadataVector;
     for (auto i : PALMetadataMap) {
       PALMetadataVector.push_back(i.first);
       PALMetadataVector.push_back(i.second);
     }
-    getTargetStreamer()->EmitPALMetadata(PALMetadataVector);
+    useTargetStreamer(
+        [&](AMDGPUTargetStreamer *TargetStreamer) {
+          TargetStreamer->EmitPALMetadata(PALMetadataVector);
+        }
+    );
   }
 }
 
 bool AMDGPUAsmPrinter::isBlockOnlyReachableByFallthrough(
   const MachineBasicBlock *MBB) const {
   if (!AsmPrinter::isBlockOnlyReachableByFallthrough(MBB))
     return false;
 
if (!MFI->isEntryFunction())
     return;
 
   const AMDGPUSubtarget &STM = MF->getSubtarget<AMDGPUSubtarget>();
   amd_kernel_code_t KernelCode;
   if (STM.isAmdCodeObjectV2(*MF)) {
     getAmdKernelCode(KernelCode, CurrentProgramInfo, *MF);
 
     OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
-    getTargetStreamer()->EmitAMDKernelCodeT(KernelCode);
+    useTargetStreamer(
+        [&](AMDGPUTargetStreamer *TargetStreamer) {
+          TargetStreamer->EmitAMDKernelCodeT(KernelCode);
+        }
+    );
   }
 
   if (TM.getTargetTriple().getOS() != Triple::AMDHSA)
     return;
 
   HSAMetadataStream.emitKernel(*MF->getFunction(),
                                getHSACodeProps(*MF, CurrentProgramInfo),
                                getHSADebugProps(*MF, CurrentProgramInfo));
 }
 
 void AMDGPUAsmPrinter::EmitFunctionEntryLabel() {
   const SIMachineFunctionInfo *MFI = MF->getInfo<SIMachineFunctionInfo>();
   const AMDGPUSubtarget &STM = MF->getSubtarget<AMDGPUSubtarget>();
   if (MFI->isEntryFunction() && STM.isAmdCodeObjectV2(*MF)) {
     SmallString<128> SymbolName;
-    getNameWithPrefix(SymbolName, MF->getFunction()),
-    getTargetStreamer()->EmitAMDGPUSymbolType(
+    getNameWithPrefix(SymbolName, MF->getFunction());
+    useTargetStreamer(
+        [&](AMDGPUTargetStreamer *TargetStreamer) {
+          TargetStreamer->EmitAMDGPUSymbolType(
               SymbolName, ELF::STT_AMDGPU_HSA_KERNEL);
         }
+    );
+  }
 
   AsmPrinter::EmitFunctionEntryLabel();
 }
 
 void AMDGPUAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
 
   // Group segment variables aren't emitted in HSA.
   if (AMDGPU::isGroupSegment(GV, AMDGPUASI))
HSADebugProps.mPrivateSegmentBufferSGPR =
         ProgramInfo.DebuggerPrivateSegmentBufferSGPR;
     HSADebugProps.mWavefrontPrivateSegmentOffsetSGPR =
         ProgramInfo.DebuggerWavefrontPrivateSegmentOffsetSGPR;
   }
 
   return HSADebugProps;
 }
 
+void AMDGPUAsmPrinter::useTargetStreamer(
+    function_ref<void(AMDGPUTargetStreamer *TargetStreamer)> Func) {
+  if (!OutStreamer)
+    return;
+
+  AMDGPUTargetStreamer *TargetStreamer =
+      static_cast<AMDGPUTargetStreamer*>(OutStreamer->getTargetStreamer());
+  if (!TargetStreamer)
+    return;
+
+  Func(TargetStreamer);
+}
+
 bool AMDGPUAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
                                        unsigned AsmVariant,
                                        const char *ExtraCode, raw_ostream &O) {
   // First try the generic code, which knows about modifiers like 'c' and 'n'.
   if (!AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, O))
     return false;
 
   if (ExtraCode && ExtraCode[0]) {