Specializing AsmStreamer InstPrinter

[colinl]

Summary

I prepared this patch and I noticed we're using composition through MCTargetStreamer to achieve a type of polymorphism as in:

MCTargetStreamer *TS = getTargetStreamer();
if (TS)
  TS->emitLabel(Symbol);

MCTargetStreamer *TS = getTargetStreamer();
if (TS)
  TS->emitAssignment(Symbol, Value);

I did this in-kind with MCAsmStreamer::getInstPrinter though let me know if we want to do this a different way, perhaps through subclassing MCAsmStreamer. Previously I had hooked createMCAsmStreamer in the TargetRegistry though this has been recently removed.

static MCStreamer *
createMCAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS,

bool isVerboseAsm,
bool useDwarfDirectory,
MCInstPrinter *IP, MCCodeEmitter *CE,
MCAsmBackend *MAB, bool ShowInst) {
HexagonAsmInstPrinter *HIP = new HexagonAsmInstPrinter(IP);
MCStreamer *S =
  llvm::createAsmStreamer(Ctx, OS, isVerboseAsm, useDwarfDirectory,
  HIP, CE, MAB, ShowInst);
new HexagonTargetAsmStreamer(*S, Ctx, OS, isVerboseAsm, HIP);
return S;

}

I needed to create a pretty-printing MCInstPrinter that llvm-mc can use when asm streaming and this seemed like the most direct way to incorporate this functionality.

The crux of the issue is many users of MCInstPrinter, llvm-mc, llvm-objdump, lldb, assume the output of MCInstPrinter is short and on one line and can be decorated in the front and back with disassembly context, function names, addresses, annotations etc. When the instruction gets longer than a line the output looks weird and should be pretty-printed by the user.

Let me know if anyone has ideas if/how this could be better implemented.

include/llvm/MC/MCStreamer.h

 class MCTargetStreamer {
 protected:
   MCStreamer &Streamer;
+  MCInstPrinter *InstPrinter;
 
 public:
   MCTargetStreamer(MCStreamer &S);
   virtual ~MCTargetStreamer();
 
+  MCInstPrinter *getInstPrinter() { return InstPrinter; }
   const MCStreamer &getStreamer() { return Streamer; }
 
   // Allow a target to add behavior to the EmitLabel of MCStreamer.

lib/MC/MCAsmStreamer.cpp

         InstPrinter->setCommentStream(CommentStream);
   }
 
+  MCInstPrinter *getInstPrinter() {
+    auto Streamer = getTargetStreamer();
+    if(Streamer != nullptr) {
+      auto Printer = Streamer->getInstPrinter();
+      if(Printer != nullptr)
+        return Printer;
+    }
+    return InstPrinter.get();
+  }
+
   inline void EmitEOL() {
     // If we don't have any comments, just emit a \n.
     if (!IsVerboseAsm) {

   if (!MAI->useDwarfRegNumForCFI()) {
     const MCRegisterInfo *MRI = getContext().getRegisterInfo();
     unsigned LLVMRegister = MRI->getLLVMRegNum(Register, true);
-    InstPrinter->printRegName(OS, LLVMRegister);
+    getInstPrinter()->printRegName(OS, LLVMRegister);
   } else {
     OS << Register;
   }

 
   // Show the MCInst if enabled.
   if (ShowInst) {
-    Inst.dump_pretty(GetCommentOS(), InstPrinter.get(), "\n ");
+    Inst.dump_pretty(GetCommentOS(), getInstPrinter(), "\n ");
     GetCommentOS() << "\n";
   }
 
-  InstPrinter->printInst(&Inst, OS, "", STI);
+  getInstPrinter()->printInst(&Inst, OS, "", STI);
 
   EmitEOL();
 }

lib/MC/MCStreamer.cpp

 // Pin the vtables to this file.
 MCTargetStreamer::~MCTargetStreamer() {}
 
-MCTargetStreamer::MCTargetStreamer(MCStreamer &S) : Streamer(S) {
+MCTargetStreamer::MCTargetStreamer(MCStreamer &S)
+    : Streamer(S), InstPrinter(nullptr) {
   S.setTargetStreamer(this);
 }
 

lib/Target/Hexagon/MCTargetDesc/HexagonInstPrinter.h

   void printInst(MCInst const *MI, raw_ostream &O, StringRef Annot,
                  MCSubtargetInfo const &STI) override;
   void printRegName(raw_ostream &O, unsigned RegNo) const override;
-  std::unique_ptr<MCInstPrinter> RawPrinter;
+  MCInstPrinter *RawPrinter;
 };
 /// Prints bundles as a newline separated list of individual instructions
 /// Duplexes are separated by a vertical tab \v character

lib/Target/Hexagon/MCTargetDesc/HexagonMCTargetDesc.cpp

 #define GET_REGINFO_MC_DESC
 #include "HexagonGenRegisterInfo.inc"
 
+namespace {
+class HexagonTargetAsmStreamer : public MCTargetStreamer {
+  formatted_raw_ostream &OS;
+  bool isVerboseAsm;
+  HexagonAsmInstPrinter IP;
+public:
+  HexagonTargetAsmStreamer(MCStreamer &S,
+                           formatted_raw_ostream &OS, MCInstPrinter *IPrinter, bool isVerboseAsm
+                           )
+                           : MCTargetStreamer(S), OS(OS), isVerboseAsm(isVerboseAsm), IP (IPrinter) {
+    InstPrinter = &IP;
+  }
+};
+}
+
 MCInstrInfo *llvm::createHexagonMCInstrInfo() {
   MCInstrInfo *X = new MCInstrInfo();
   InitHexagonMCInstrInfo(X);

    return nullptr;
 }
 
+static MCTargetStreamer *
+createMCAsmTargetStreamer(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint,
+      bool IsVerboseAsm) {
+  return new HexagonTargetAsmStreamer(S, OS, InstPrint, IsVerboseAsm);
+}
+
 // Force static initialization.
 extern "C" void LLVMInitializeHexagonTargetMC() {
   // Register the MC asm info.

   TargetRegistry::RegisterMCCodeEmitter(TheHexagonTarget,
                                         createHexagonMCCodeEmitter);
 
+  // Register the asm streamer
+  TargetRegistry::RegisterAsmTargetStreamer(TheHexagonTarget,
+                                            createMCAsmTargetStreamer);
+
   // Register the MC Inst Printer
   TargetRegistry::RegisterMCInstPrinter(TheHexagonTarget,
                                         createHexagonMCInstPrinter);