[llvm-readobj] Add support for dumping macho min version load command

[davide]

Summary

Example output:

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

Cmd: LC_VERSION_MIN_IPHONEOS
Size: 16
Version: 99.8.7
SDK: n/a

}

Meta-question: is this the granularity we want? llvm-objdump dumps this as part of -private-headers. Should I change that to match that behavior, or is it fine?
Tests will be added when this replaces macho-dump.

[• rafael]

LGTM

tools/llvm-readobj/MachODumper.cpp

636

StringRef

tools/llvm-readobj/MachODumper.cpp

public:
   void printRelocations() override;
   void printSymbols() override;
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
   void printStackMap() const override;
 
   // MachO-specific.
   void printMachODataInCode() override;
+  void printMachOVersionMin() 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_DATA_IN_CODE) {
         W.printNumber("Index", i);
         W.printNumber("Offset", DICE.offset);
         W.printNumber("Length", DICE.length);
         W.printNumber("Kind", DICE.kind);
       }
     }
   }
 }
+
+void MachODumper::printMachOVersionMin() {
+  for (const auto &Load : Obj->load_commands()) {
+    if (Load.C.cmd == MachO::LC_VERSION_MIN_MACOSX ||
+        Load.C.cmd == MachO::LC_VERSION_MIN_IPHONEOS) {
+      MachO::version_min_command VMC = Obj->getVersionMinLoadCommand(Load);
+      DictScope Group(W, "MinVersion");
+      SmallString<32> Cmd;
+      if (Load.C.cmd == MachO::LC_VERSION_MIN_MACOSX)
+        Cmd = "LC_VERSION_MIN_MACOSX";
+      else
+        Cmd = "LC_VERSION_MIN_IPHONEOS";
+      W.printString("Cmd", Cmd);
+      W.printNumber("Size", VMC.cmdsize);
+      SmallString<32> Version;
+      Version = utostr(MachOObjectFile::getVersionMinMajor(VMC, false)) + "." +
+        utostr(MachOObjectFile::getVersionMinMinor(VMC, false));
+      uint32_t Update = MachOObjectFile::getVersionMinUpdate(VMC, false);
+      if (Update != 0)
+        Version += "." + utostr(MachOObjectFile::getVersionMinUpdate(VMC,
+                                                                     false));
+      W.printString("Version", Version);
+      SmallString<32> SDK;
+      if (VMC.sdk == 0)
+        SDK = "n/a";
+      else {
+        SDK = utostr(MachOObjectFile::getVersionMinMajor(VMC, true)) + "." +
+          utostr(MachOObjectFile::getVersionMinMinor(VMC, true));
+        uint32_t Update = MachOObjectFile::getVersionMinUpdate(VMC, true);
+        if (Update != 0)
+          SDK += "." + utostr(MachOObjectFile::getVersionMinUpdate(VMC,
+                                                                   true));
+      }
+      W.printString("SDK", SDK);
+    }
+  }
+}

tools/llvm-readobj/ObjDumper.h

public:
   // Only implemented for PE/COFF.
   virtual void printCOFFImports() { }
   virtual void printCOFFExports() { }
   virtual void printCOFFDirectives() { }
   virtual void printCOFFBaseReloc() { }
 
   // Only implemented for MachO.
   virtual void printMachODataInCode() { }
+  virtual void printMachOVersionMin() { }
 
   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-version-min
+  cl::opt<bool>
+  MachOVersionMin("macho-version-min",
+                  cl::desc("Display MachO version min command"));
   // -stackmap
   cl::opt<bool>
   PrintStackMap("stackmap",
                 cl::desc("Display contents of stackmap section"));
 
 } // namespace opts
 
 namespace llvm {
if (Obj->isCOFF()) {
     if (opts::COFFDirectives)
       Dumper->printCOFFDirectives();
     if (opts::COFFBaseRelocs)
       Dumper->printCOFFBaseReloc();
   }
   if (Obj->isMachO())
     if (opts::MachODataInCode)
       Dumper->printMachODataInCode();
+    if (opts::MachOVersionMin)
+      Dumper->printMachOVersionMin();
   if (opts::PrintStackMap)
     Dumper->printStackMap();
 }
 
 /// @brief Dumps each object file in \a Arc;
 static void dumpArchive(const Archive *Arc) {
   for (const auto &Child : Arc->children()) {
     ErrorOr<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary();