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.

llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp

 
 bool llvm::RelocAddressLess(RelocationRef a, RelocationRef b) {
   uint64_t a_addr, b_addr;
   if (error(a.getOffset(a_addr))) return false;
   if (error(b.getOffset(b_addr))) return false;
   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) {
+    outs() << format("%8" PRIx64 ":", Address);
+    if (!NoShowRawInsn) {
+      outs() << "\t";
+      dumpBytes(Bytes, outs());
+    }
+    IP.printInst(MI, outs(), "", STI);
+  }
+};
+PrettyPrinter PrettyPrinterInst;
+PrettyPrinter &selectPrettyPrinter(Triple const &Triple, MCInstPrinter &IP) {
+  switch(Triple.getArch()) {
+  default:
+    return PrettyPrinterInst;
+  }
+}
+}
+
 static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
   const Target *TheTarget = getTarget(Obj);
   // getTarget() will have already issued a diagnostic if necessary, so
   // just bail here if it failed.
   if (!TheTarget)
     return;
 
   // Package up features to be passed to target/subtarget
static void DisassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
   int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
   std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
       Triple(TripleName), AsmPrinterVariant, *AsmInfo, *MII, *MRI));
   if (!IP) {
     errs() << "error: no instruction printer for target " << TripleName
       << '\n';
     return;
   }
+  PrettyPrinter &PIP = selectPrettyPrinter(Triple(TripleName), *IP);
 
   StringRef Fmt = Obj->getBytesInAddress() > 4 ? "\t\t%016" PRIx64 ":  " :
                                                  "\t\t\t%08" PRIx64 ":  ";
 
   // Create a mapping, RelocSecs = SectionRelocMap[S], where sections
   // in RelocSecs contain the relocations for section S.
   std::error_code EC;
   std::map<SectionRef, SmallVector<SectionRef, 1>> SectionRelocMap;

 #endif
 
       for (Index = Start; Index < End; Index += Size) {
         MCInst Inst;
 
         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), outs());
-          }
-          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";
         } else {
           errs() << ToolName << ": warning: invalid instruction encoding\n";
           if (Size == 0)
             Size = 1; // skip illegible bytes
         }