[llvm-readobj] Dump Macho indirect symbols

[davide]

Summary

This is *probably* the last bit we need. After this lands, it's just a lot of fun converting all the remaining tests to the new format.

Also, example output:

File: <stdin>
Format: Mach-O 32-bit i386
Arch: i386
AddressSize: 32bit
Indirect Symbols {

Number: 6
Symbols [
  Entry {
    Entry Index: 0
    Symbol Index: 0x4
  }
  Entry {
    Entry Index: 1
    Symbol Index: 0x0
  }
  Entry {
    Entry Index: 2
    Symbol Index: 0x1
  }
  Entry {
    Entry Index: 3
    Symbol Index: 0x5
  }
  Entry {
    Entry Index: 4
    Symbol Index: 0x80000000
  }
  Entry {
    Entry Index: 5
    Symbol Index: 0xC0000000
  }
]

}

[echristo]

LGTM, and thanks again for doing all this.

tools/llvm-readobj/MachODumper.cpp

public:
   void printUnwindInfo() override;
   void printStackMap() const override;
 
   // MachO-specific.
   void printMachODataInCode() override;
   void printMachOVersionMin() override;
   void printMachODysymtab() override;
   void printMachOSegment() override;
+  void printMachOIndirectSymbols() override;
 
 private:
   template<class MachHeader>
   void printFileHeaders(const MachHeader &Header);
 
   void printSymbol(const SymbolRef &Symbol);
 
   void printRelocation(const RelocationRef &Reloc);
if (Load.C.cmd == MachO::LC_SEGMENT || Load.C.cmd == MachO::LC_SEGMENT_64) {
       W.printNumber("filesize", MOSegment.fileoff);
       W.printString("maxprot", getMask(MOSegment.maxprot));
       W.printString("initprot", getMask(MOSegment.initprot));
       W.printNumber("nsects", MOSegment.nsects);
       W.printHex("flags", MOSegment.flags);
     }
   }
 }
+
+void MachODumper::printMachOIndirectSymbols() {
+  for (const auto &Load : Obj->load_commands()) {
+    if (Load.C.cmd == MachO::LC_DYSYMTAB) {
+      MachO::dysymtab_command DLC = Obj->getDysymtabLoadCommand();
+      DictScope Group(W, "Indirect Symbols");
+      W.printNumber("Number", DLC.nindirectsyms);
+      ListScope D(W, "Symbols");
+      for (unsigned i = 0; i < DLC.nindirectsyms; ++i) {
+        DictScope Group(W, "Entry");
+        W.printNumber("Entry Index", i);
+        W.printHex("Symbol Index", Obj->getIndirectSymbolTableEntry(DLC, i));
+      }
+    }
+  }
+}

tools/llvm-readobj/ObjDumper.h

public:
   virtual void printCOFFDirectives() { }
   virtual void printCOFFBaseReloc() { }
 
   // Only implemented for MachO.
   virtual void printMachODataInCode() { }
   virtual void printMachOVersionMin() { }
   virtual void printMachODysymtab() { }
   virtual void printMachOSegment() { }
+  virtual void printMachOIndirectSymbols() { }
 
   virtual void printStackMap() const = 0;
 
 protected:
   StreamWriter& W;
 };
 
 std::error_code createCOFFDumper(const object::ObjectFile *Obj,

tools/llvm-readobj/llvm-readobj.cpp

namespace opts {
   COFFBaseRelocs("coff-basereloc",
                  cl::desc("Display the PE/COFF .reloc section"));
 
   // -macho-data-in-code
   cl::opt<bool>
   MachODataInCode("macho-data-in-code",
                   cl::desc("Display MachO Data in Code command"));
 
+  // -macho-indirect-symbols
+  cl::opt<bool>
+  MachOIndirectSymbols("macho-indirect-symbols",
+                  cl::desc("Display MachO indirect symbols"));
+
   // -macho-segment
   cl::opt<bool>
   MachOSegment("macho-segment",
                   cl::desc("Display MachO Segment command"));
 
   // -macho-version-min
   cl::opt<bool>
   MachOVersionMin("macho-version-min",
if (Obj->isCOFF()) {
     if (opts::COFFDirectives)
       Dumper->printCOFFDirectives();
     if (opts::COFFBaseRelocs)
       Dumper->printCOFFBaseReloc();
   }
   if (Obj->isMachO()) {
     if (opts::MachODataInCode)
       Dumper->printMachODataInCode();
+    if (opts::MachOIndirectSymbols)
+      Dumper->printMachOIndirectSymbols();
     if (opts::MachOSegment)
       Dumper->printMachOSegment();
     if (opts::MachOVersionMin)
       Dumper->printMachOVersionMin();
     if (opts::MachODysymtab)
       Dumper->printMachODysymtab();
   }
   if (opts::PrintStackMap)