PPC: Implement null target streamer

[arsenm]

ping

[arsenm]

ping

[arsenm]

ping

[arsenm]

ping

[shchenz]

llvm/lib/Target/PowerPC/PPCTargetStreamer.h

31

Instead of making the base PPCTargetStreamer as a null streamer, does it make more sense to add a new child class PPCTargetNullStreamer in lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp?

[arsenm]

llvm/lib/Target/PowerPC/PPCTargetStreamer.h

31

More boilerplate for no gain

[shchenz]

LGTM. Thanks for improving this for PPC.

llvm/lib/Target/PowerPC/PPCTargetStreamer.h

31

OK. Seems more targets reuse base class as null streamer.

[arsenm]

0ebab8bae4215000ec73c0233f929466fc05a038

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

 
 static MCTargetStreamer *createAsmTargetStreamer(MCStreamer &S,
                                                  formatted_raw_ostream &OS,
                                                  MCInstPrinter *InstPrint,
                                                  bool isVerboseAsm) {
   return new PPCTargetAsmStreamer(S, OS);
 }
 
+static MCTargetStreamer *createNullTargetStreamer(MCStreamer &S) {
+  return new PPCTargetStreamer(S);
+}
+
 static MCTargetStreamer *
 createObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
   const Triple &TT = STI.getTargetTriple();
   if (TT.isOSBinFormatELF())
     return new PPCTargetELFStreamer(S);
   if (TT.isOSBinFormatXCOFF())
     return new PPCTargetXCOFFStreamer(S);
   return new PPCTargetMachOStreamer(S);
for (Target *T : {&getThePPC32Target(), &getThePPC32LETarget(),
 
     // Register the object target streamer.
     TargetRegistry::RegisterObjectTargetStreamer(*T,
                                                  createObjectTargetStreamer);
 
     // Register the asm target streamer.
     TargetRegistry::RegisterAsmTargetStreamer(*T, createAsmTargetStreamer);
 
+    // Register the null target streamer.
+    TargetRegistry::RegisterNullTargetStreamer(*T, createNullTargetStreamer);
+
     // Register the MCInstPrinter.
     TargetRegistry::RegisterMCInstPrinter(*T, createPPCMCInstPrinter);
   }
 }

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

llvm_unreachable("Tail call is handled in the normal case. See comments "
                      "around this assert.");
   }
 }
 
 void PPCLinuxAsmPrinter::emitStartOfAsmFile(Module &M) {
   if (static_cast<const PPCTargetMachine &>(TM).isELFv2ABI()) {
     PPCTargetStreamer *TS =
       static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
-
-    if (TS)
-      TS->emitAbiVersion(2);
   }
 
   if (static_cast<const PPCTargetMachine &>(TM).isPPC64() ||
       !isPositionIndependent())
     return AsmPrinter::emitStartOfAsmFile(M);
 
   if (M.getPICLevel() == PICLevel::SmallPIC)
     return AsmPrinter::emitStartOfAsmFile(M);
if (!TOC.empty()) {
     if (!isPPC64)
       OutStreamer->emitValueToAlignment(4);
 
     for (const auto &TOCMapPair : TOC) {
       const MCSymbol *const TOCEntryTarget = TOCMapPair.first.first;
       MCSymbol *const TOCEntryLabel = TOCMapPair.second;
 
       OutStreamer->emitLabel(TOCEntryLabel);
-      if (isPPC64 && TS != nullptr)
+      if (isPPC64)
         TS->emitTCEntry(*TOCEntryTarget, TOCMapPair.first.second);
       else
         OutStreamer->emitSymbolValue(TOCEntryTarget, 4);
     }
   }
 
   PPCAsmPrinter::emitEndOfAsmFile(M);
 }
if (NonPCrelGEPRequired || PCrelGEPRequired) {
     const MCSymbolRefExpr *LocalEntryLabelExp =
        MCSymbolRefExpr::create(LocalEntryLabel, OutContext);
     const MCExpr *LocalOffsetExp =
       MCBinaryExpr::createSub(LocalEntryLabelExp,
                               GlobalEntryLabelExp, OutContext);
 
     PPCTargetStreamer *TS =
       static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
-
-    if (TS)
-      TS->emitLocalEntry(cast<MCSymbolELF>(CurrentFnSym), LocalOffsetExp);
   } else if (Subtarget->isUsingPCRelativeCalls()) {
     // When generating the entry point for a function we have a few scenarios
     // based on whether or not that function uses R2 and whether or not that
     // function makes calls (or is a leaf function).
     // 1) A leaf function that does not use R2 (or treats it as callee-saved
     //    and preserves it). In this case st_other=0 and both
     //    the local and global entry points for the function are the same.
     //    No special entry point code is required.
if (NonPCrelGEPRequired || PCrelGEPRequired) {
     // 4) The function does not use the TOC pointer but R2 is used inside
     //    the function. In this case st_other=1 once again.
     // 5) This function uses inline asm. We mark R2 as reserved if the function
     //    has inline asm as we have to assume that it may be used.
     if (MF->getFrameInfo().hasCalls() || MF->getFrameInfo().hasTailCall() ||
         MF->hasInlineAsm() || (!PPCFI->usesTOCBasePtr() && UsesX2OrR2)) {
       PPCTargetStreamer *TS =
           static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
-      if (TS)
-        TS->emitLocalEntry(cast<MCSymbolELF>(CurrentFnSym),
-                           MCConstantExpr::create(1, OutContext));
     }
   }
 }
 
 /// EmitFunctionBodyEnd - Print the traceback table before the .size
 /// directive.
 ///
 void PPCLinuxAsmPrinter::emitFunctionBodyEnd() {
if (I.first.second == MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSGDM) {
           getObjFileLowering().getSectionForTOCEntry(S, TM));
     } else {
       TCEntry = cast<MCSectionXCOFF>(
           getObjFileLowering().getSectionForTOCEntry(I.first.first, TM));
     }
     OutStreamer->switchSection(TCEntry);
 
     OutStreamer->emitLabel(I.second);
-    if (TS != nullptr)
-      TS->emitTCEntry(*I.first.first, I.first.second);
   }
 
   for (const auto *GV : TOCDataGlobalVars)
     emitGlobalVariableHelper(GV);
 }
 
 bool PPCAIXAsmPrinter::doInitialization(Module &M) {
   const bool Result = PPCAsmPrinter::doInitialization(M);

llvm/lib/Target/PowerPC/PPCTargetStreamer.h

 class MCSymbolELF;
 
 class PPCTargetStreamer : public MCTargetStreamer {
 public:
   PPCTargetStreamer(MCStreamer &S);
   ~PPCTargetStreamer() override;
 
   virtual void emitTCEntry(const MCSymbol &S,
-                           MCSymbolRefExpr::VariantKind Kind) = 0;
-  virtual void emitMachine(StringRef CPU) = 0;
-  virtual void emitAbiVersion(int AbiVersion) = 0;
-  virtual void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset) = 0;
+                           MCSymbolRefExpr::VariantKind Kind){};
+  virtual void emitMachine(StringRef CPU){};
+  virtual void emitAbiVersion(int AbiVersion){};
+  virtual void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset){};
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_POWERPC_PPCTARGETSTREAMER_H