Add method to MCInstPrinter for printing with disassembly context

[colinl]

Summary

Add a virtual method to MCInstPrinter which allows backends to specialize how the instruction is printed.

Generally this allows backends greater ability to format their instructions when being printed with a disassembly context like with objdump.

Specifically on Hexagon this allows us to print VLIW instructions in an 80-column readable way by placing one instruction per line and putting the disassembled bytes next to the associated instruction.

[• rafael]

I think this is fine with a few changes.

Do you have the patch actually using this ready somewhere?

include/llvm/MC/MCInstPrinter.h

26 ↗

(On Diff #22224)

dumpBytes

lib/MC/MCInstPrinter.cpp

20 ↗

(On Diff #22224)

This can now be static, no?

26 ↗

(On Diff #22224)

Why not send the chars to OS directly?

[colinl]

This is a sketch of looping we use to generate bundles:

for(auto i(MI.begin()), j (MI.end()); i != j; ++i) {
  OS << format("%8" PRIx64 ":", Address);
  Address += HEXAGON_INSTR_SIZE;
  if (ShowRawInsn) {
    OS << "\t";
    DumpBytes(StringRef(
      reinterpret_cast<const char *>(Bytes.data()), HEXAGON_INSTR_SIZE),
              HEXAGON_INSTR_SIZE, true, true);
    Bytes = Bytes.slice(HEXAGON_INSTR_SIZE);
  }
  if(i == MI.begin())
    OS << " { ";
  else
    OS << "   ";
  MCInst const * Inst = i->getInst();
  PrintOneInst(*Inst, OS);
  if(i + 1 == MI.end())
    OS << " }";
  else
    OS << '\n';
}
if(HexagonMCInstrInfo::IsEnd0(MI))
  OS << ":endloop0";
if(HexagonMCInstrInfo::IsEnd1(MI))
  OS << ":endloop1";

And it produces output like this:

0:       a3 43 02 8e 8e0243a3 { r3 += lsr(r2, #3)
4:       00 40 20 5c 5c204000   if (!p0) jump 0x0
8:       24 40 c1 41 41c14024   if (p0) r5:4 = memd(r1 + #8)
c:       08 e4 c0 ab abc0e408   if (p0) memd(r0++#8) = r5:4 }

lib/MC/MCInstPrinter.cpp

20 ↗

(On Diff #22224)

It's still used inside MachODump in a couple places.

26 ↗

(On Diff #22224)

Good point, I'll make that change.

[• rafael]

LGTM with the DumpBytes change and the condition this will be used soon :-)

[colinl]

I've been working more on this and have reconsidered the design. The issue I ran in to is there are other users of InstPrinter that need to render the instruction in different ways. The other major example besides objdump is lldb which prints out additional information like the function name and offset.

If things were done as in the last patch, each user of InstPrinter could require a new virtual method containing the information it wants to display, effectively InstPrinter would need to know about all its users.

This patch moves the rendering to the user which leaves InstPrinter unchanged. LLDB has existing infrastructure to do similar target-specific rendering.

tools/llvm-objdump/llvm-objdump.cpp

   return a_addr < b_addr;
 }
 
+namespace {
+class PrettyPrinter {
+public:
+  virtual void printInst(MCInstPrinter &IP, const MCInst *MI, bool ShowRawInsn,
+                         ArrayRef<uint8_t> Bytes, uint64_t Address,
+                         raw_ostream &OS, StringRef Annot,
+                         MCSubtargetInfo const &STI) {
+    OS << format("%8" PRIx64 ":", Address);
+    if (ShowRawInsn) {
+      OS << "\t";
+      DumpBytes(Bytes);
+    }
+    IP.printInst(MI, OS, Annot, STI);
+    OS << "\n";
+  }
+};
+PrettyPrinter PrettyPrinterInst;
+class HexagonPrettyPrinter : public PrettyPrinter {
+public:
+  void printInst(MCInstPrinter &IP, const MCInst *MI, bool ShowRawInsn,
+                 ArrayRef<uint8_t> Bytes, uint64_t Address,
+                 raw_ostream &OS, StringRef Annot,
+                 MCSubtargetInfo const &STI) override {
+    // Special printing
+  }
+};
+HexagonPrettyPrinter HexagonPrettyPrinterInst;
+PrettyPrinter &selectPrettyPrinter(Triple const &Triple, MCInstPrinter &IP) {
+  switch(Triple.getArch()) {
+  default:
+    return PrettyPrinterInst;
+  case Triple::hexagon:
+    return HexagonPrettyPrinterInst;
+  }
+}
+}
+
 static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
   const Target *TheTarget = getTarget(Obj);
   // getTarget() will have already issued a diagnostic if necessary, so

       << '\n';
     return;
   }
+  PrettyPrinter &PIP = selectPrettyPrinter(Triple(TripleName), *IP);
 
   StringRef Fmt = Obj->getBytesInAddress() > 4 ? "\t\t%016" PRIx64 ":  " :
                                                  "\t\t\t%08" PRIx64 ":  ";

         if (DisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
                                    SectionAddr + Index, DebugOut,
                                    CommentStream)) {
-          outs() << format("%8" PRIx64 ":", SectionAddr + Index);
-          if (!NoShowRawInsn) {
-            outs() << "\t";
-            DumpBytes(ArrayRef<uint8_t>(Bytes.data() + Index, Size));
-          }
-          IP->printInst(&Inst, outs(), "", *STI);
+          PIP.printInst(*IP, &Inst, !NoShowRawInsn,
+                        Bytes.slice(Index, Size),
+                        SectionAddr + Index, outs(), "", *STI);
           outs() << CommentStream.str();
           Comments.clear();
           outs() << "\n";