[llvm-readobj] MachO: Dump segment command

[davide]

Summary

Example output:

File: <stdin>
Format: Mach-O arm
Arch: arm
AddressSize: 32bit
Segment {

Cmd: LC_SEGMENT
Name:
Size: 260
vmaddr: 0x0
vmsize: 0x10
fileoff: 408
filesize: 408
maxprot: rwx
initprot: rwx
nsects: 3
flags: 0x0

}

[• rafael]

LGTM

llvm/trunk/tools/llvm-readobj/MachODumper.cpp

public:
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
   void printStackMap() const override;
 
   // MachO-specific.
   void printMachODataInCode() override;
   void printMachOVersionMin() override;
   void printMachODysymtab() override;
+  void printMachOSegment() override;
 
 private:
   template<class MachHeader>
   void printFileHeaders(const MachHeader &Header);
 
   void printSymbol(const SymbolRef &Symbol);
 
   void printRelocation(const RelocationRef &Reloc);
struct MachOSection {
     uint32_t RelocationTableOffset;
     uint32_t NumRelocationTableEntries;
     uint32_t Flags;
     uint32_t Reserved1;
     uint32_t Reserved2;
     uint32_t Reserved3;
   };
 
+  struct MachOSegment {
+    StringRef CmdName;
+    StringRef SegName;
+    uint64_t cmdsize;
+    uint64_t vmaddr;
+    uint64_t vmsize;
+    uint64_t fileoff;
+    uint64_t filesize;
+    uint32_t maxprot;
+    uint32_t initprot;
+    uint32_t nsects;
+    uint32_t flags;
+  };
+
   struct MachOSymbol {
     uint32_t StringIndex;
     uint8_t Type;
     uint8_t SectionIndex;
     uint16_t Flags;
     uint64_t Value;
   };
 }
 
+static std::string getMask(uint32_t prot)
+{
+  // TODO (davide): This always assumes prot is valid.
+  // Catch mistakes and report if needed.
+  std::string Prot;
+  Prot = "";
+  Prot += (prot & MachO::VM_PROT_READ) ? "r" : "-";
+  Prot += (prot & MachO::VM_PROT_WRITE) ? "w" : "-";
+  Prot += (prot & MachO::VM_PROT_EXECUTE) ? "x" : "-";
+  return Prot;
+}
+
 static void getSection(const MachOObjectFile *Obj,
                        DataRefImpl Sec,
                        MachOSection &Section) {
   if (!Obj->is64Bit()) {
     MachO::section Sect = Obj->getSection(Sec);
     Section.Address     = Sect.addr;
     Section.Size        = Sect.size;
     Section.Offset      = Sect.offset;
static void getSection(const MachOObjectFile *Obj,
   Section.RelocationTableOffset = Sect.reloff;
   Section.NumRelocationTableEntries = Sect.nreloc;
   Section.Flags       = Sect.flags;
   Section.Reserved1   = Sect.reserved1;
   Section.Reserved2   = Sect.reserved2;
   Section.Reserved3   = Sect.reserved3;
 }
 
+static void getSegment(const MachOObjectFile *Obj,
+                       const MachOObjectFile::LoadCommandInfo &L,
+                       MachOSegment &Segment) {
+  if (!Obj->is64Bit()) {
+    MachO::segment_command SC = Obj->getSegmentLoadCommand(L);
+    Segment.CmdName = "LC_SEGMENT";
+    Segment.SegName = SC.segname;
+    Segment.cmdsize = SC.cmdsize;
+    Segment.vmaddr = SC.vmaddr;
+    Segment.vmsize = SC.vmsize;
+    Segment.fileoff = SC.fileoff;
+    Segment.filesize = SC.filesize;
+    Segment.maxprot = SC.maxprot;
+    Segment.initprot = SC.initprot;
+    Segment.nsects = SC.nsects;
+    Segment.flags = SC.flags;
+    return;
+  }
+  MachO::segment_command_64 SC = Obj->getSegment64LoadCommand(L);
+  Segment.CmdName = "LC_SEGMENT_64";
+  Segment.SegName = SC.segname;
+  Segment.cmdsize = SC.cmdsize;
+  Segment.vmaddr = SC.vmaddr;
+  Segment.vmsize = SC.vmsize;
+  Segment.fileoff = SC.fileoff;
+  Segment.filesize = SC.filesize;
+  Segment.maxprot = SC.maxprot;
+  Segment.initprot = SC.initprot;
+  Segment.nsects = SC.nsects;
+  Segment.flags = SC.flags;
+}
 
 static void getSymbol(const MachOObjectFile *Obj,
                       DataRefImpl DRI,
                       MachOSymbol &Symbol) {
   if (!Obj->is64Bit()) {
     MachO::nlist Entry = Obj->getSymbolTableEntry(DRI);
     Symbol.StringIndex  = Entry.n_strx;
     Symbol.Type         = Entry.n_type;
if (Load.C.cmd == MachO::LC_DYSYMTAB) {
       W.printNumber("nindirectsyms", DLC.nindirectsyms);
       W.printNumber("extreloff", DLC.extreloff);
       W.printNumber("nextrel", DLC.nextrel);
       W.printNumber("locreloff", DLC.locreloff);
       W.printNumber("nlocrel", DLC.nlocrel);
     }
   }
 }
+
+void MachODumper::printMachOSegment() {
+  for (const auto &Load : Obj->load_commands()) {
+    if (Load.C.cmd == MachO::LC_SEGMENT || Load.C.cmd == MachO::LC_SEGMENT_64) {
+      MachOSegment MOSegment;
+      getSegment(Obj, Load, MOSegment);
+      DictScope Group(W, "Segment");
+      W.printString("Cmd", MOSegment.CmdName);
+      W.printString("Name", MOSegment.SegName);
+      W.printNumber("Size", MOSegment.cmdsize);
+      W.printHex("vmaddr", MOSegment.vmaddr);
+      W.printHex("vmsize", MOSegment.vmsize);
+      W.printNumber("fileoff", MOSegment.fileoff);
+      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);
+    }
+  }
+}

llvm/trunk/tools/llvm-readobj/ObjDumper.h

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

llvm/trunk/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-segment
+  cl::opt<bool>
+  MachOSegment("macho-segment",
+                  cl::desc("Display MachO Segment command"));
+
   // -macho-version-min
   cl::opt<bool>
   MachOVersionMin("macho-version-min",
                   cl::desc("Display MachO version min command"));
 
   // -macho-dysymtab
   cl::opt<bool>
   MachODysymtab("macho-dysymtab",
if (Obj->isCOFF()) {
     if (opts::COFFDirectives)
       Dumper->printCOFFDirectives();
     if (opts::COFFBaseRelocs)
       Dumper->printCOFFBaseReloc();
   }
   if (Obj->isMachO()) {
     if (opts::MachODataInCode)
       Dumper->printMachODataInCode();
+    if (opts::MachOSegment)
+      Dumper->printMachOSegment();
     if (opts::MachOVersionMin)
       Dumper->printMachOVersionMin();
     if (opts::MachODysymtab)
       Dumper->printMachODysymtab();
   }
   if (opts::PrintStackMap)
     Dumper->printStackMap();
 }