[Object, MachO] Introduce MachOObjectFile::load_commands() range iterator.

[samsonov]

Summary

Now users don't have to manually deal with getFirstLoadCommandInfo() /
getNextLoadCommandInfo(), calculate the number of load segments, etc.
Additionally, the iterator has a support for error handling, that
would allow to detect the case when the next load command cannot be
parsed.

[samsonov]

Wait a second, this is stupid. We're walking through all load commands in the constructor and fail to create an object if another command can't be parsed. We should just cache all the load commands in a vector, and get rid of all this ErrorOr<> stuff. I'll update the patch shortly, sorry for noise.

[• rafael]

If we can instead avoid walking all the load commands that would be
even better :-)

[samsonov]

• Parse all MachO load commands in constructor, and store them in a vector.

[samsonov]

Alright, now this changes significantly simplifies the users' code - they can use a simple foreach to iterate over all load commands. I will add error recovery for the case when we can't parse load command info in a subsequent change. This one has NFC. Please take a look.

[• rafael]

LGTM, thanks

include/llvm/Object/MachO.h

 typedef content_iterator<MachOBindEntry> bind_iterator;
 
 class MachOObjectFile : public ObjectFile {
 public:
   struct LoadCommandInfo {
     const char *Ptr;      // Where in memory the load command is.
     MachO::load_command C; // The command itself.
   };
+  typedef SmallVector<LoadCommandInfo, 4> LoadCommandList;
+  typedef LoadCommandList::const_iterator load_command_iterator;
 
   MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian, bool Is64Bits,
                   std::error_code &EC);
 
   void moveSymbolNext(DataRefImpl &Symb) const override;
   std::error_code getSymbolName(DataRefImpl Symb,
                                 StringRef &Res) const override;
 
public:
   unsigned getArch() const override;
   Triple getArch(const char **McpuDefault, Triple *ThumbTriple) const;
 
   relocation_iterator section_rel_begin(unsigned Index) const;
   relocation_iterator section_rel_end(unsigned Index) const;
 
   dice_iterator begin_dices() const;
   dice_iterator end_dices() const;
-  
+  load_command_iterator begin_load_commands() const;
+  load_command_iterator end_load_commands() const;
+  iterator_range<load_command_iterator> load_commands() const;
+
   /// For use iterating over all exported symbols.
   iterator_range<export_iterator> exports() const;
-  
   /// For use examining a trie not in a MachOObjectFile.
   static iterator_range<export_iterator> exports(ArrayRef<uint8_t> Trie);
 
   /// For use iterating over all rebase table entries.
   iterator_range<rebase_iterator> rebaseTable() const;
 
   /// For use examining rebase opcodes not in a MachOObjectFile.
   static iterator_range<rebase_iterator> rebaseTable(ArrayRef<uint8_t> Opcodes,
public:
   uint32_t getScatteredRelocationType(
                                     const MachO::any_relocation_info &RE) const;
   unsigned getAnyRelocationAddress(const MachO::any_relocation_info &RE) const;
   unsigned getAnyRelocationPCRel(const MachO::any_relocation_info &RE) const;
   unsigned getAnyRelocationLength(const MachO::any_relocation_info &RE) const;
   unsigned getAnyRelocationType(const MachO::any_relocation_info &RE) const;
   SectionRef getAnyRelocationSection(const MachO::any_relocation_info &RE) const;
 
-  // Walk load commands.
-  LoadCommandInfo getFirstLoadCommandInfo() const;
-  LoadCommandInfo getNextLoadCommandInfo(const LoadCommandInfo &L) const;
-
   // MachO specific structures.
   MachO::section getSection(DataRefImpl DRI) const;
   MachO::section_64 getSection64(DataRefImpl DRI) const;
   MachO::section getSection(const LoadCommandInfo &L, unsigned Index) const;
   MachO::section_64 getSection64(const LoadCommandInfo &L,unsigned Index) const;
   MachO::nlist getSymbolTableEntry(DataRefImpl DRI) const;
   MachO::nlist_64 getSymbol64TableEntry(DataRefImpl DRI) const;
 
public:
 
   bool hasPageZeroSegment() const { return HasPageZeroSegment; }
 
   static bool classof(const Binary *v) {
     return v->isMachO();
   }
 
 private:
+  // Walk load commands.
+  LoadCommandInfo getFirstLoadCommandInfo() const;
+  LoadCommandInfo getNextLoadCommandInfo(const LoadCommandInfo &L) const;
+
   typedef SmallVector<const char*, 1> SectionList;
   SectionList Sections;
   typedef SmallVector<const char*, 1> LibraryList;
   LibraryList Libraries;
+  LoadCommandList LoadCommands;
   typedef SmallVector<StringRef, 1> LibraryShortName;
   mutable LibraryShortName LibrariesShortNames;
   const char *SymtabLoadCmd;
   const char *DysymtabLoadCmd;
   const char *DataInCodeLoadCmd;
   const char *LinkOptHintsLoadCmd;
   const char *DyldInfoLoadCmd;
   const char *UuidLoadCmd;

lib/Object/MachOObjectFile.cpp

: ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object),
       HasPageZeroSegment(false) {
   uint32_t LoadCommandCount = this->getHeader().ncmds;
   if (LoadCommandCount == 0)
     return;
 
   MachO::LoadCommandType SegmentLoadType = is64Bit() ?
     MachO::LC_SEGMENT_64 : MachO::LC_SEGMENT;
 
-  MachOObjectFile::LoadCommandInfo Load = getFirstLoadCommandInfo();
-  for (unsigned I = 0; ; ++I) {
+  LoadCommandInfo Load = getFirstLoadCommandInfo();
+  for (unsigned I = 0; I < LoadCommandCount; ++I) {
+    LoadCommands.push_back(Load);
     if (Load.C.cmd == MachO::LC_SYMTAB) {
       // Multiple symbol tables
       if (SymtabLoadCmd) {
         EC = object_error::parse_failed;
         return;
       }
       SymtabLoadCmd = Load.Ptr;
     } else if (Load.C.cmd == MachO::LC_DYSYMTAB) {
if (Load.C.cmd == MachO::LC_SYMTAB) {
         HasPageZeroSegment = true;
     } else if (Load.C.cmd == MachO::LC_LOAD_DYLIB ||
                Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB ||
                Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB ||
                Load.C.cmd == MachO::LC_REEXPORT_DYLIB ||
                Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) {
       Libraries.push_back(Load.Ptr);
     }
-
-    if (I == LoadCommandCount - 1)
-      break;
-    else
+    if (I < LoadCommandCount - 1)
       Load = getNextLoadCommandInfo(Load);
   }
+  assert(LoadCommands.size() == LoadCommandCount);
 }
 
 void MachOObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
   unsigned SymbolTableEntrySize = is64Bit() ?
     sizeof(MachO::nlist_64) :
     sizeof(MachO::nlist);
   Symb.p += SymbolTableEntrySize;
 }
return bindTable(getDyldInfoLazyBindOpcodes(), is64Bit(),
                    MachOBindEntry::Kind::Lazy);
 }
 
 iterator_range<bind_iterator> MachOObjectFile::weakBindTable() const {
   return bindTable(getDyldInfoWeakBindOpcodes(), is64Bit(),
                    MachOBindEntry::Kind::Weak);
 }
 
+MachOObjectFile::load_command_iterator
+MachOObjectFile::begin_load_commands() const {
+  return LoadCommands.begin();
+}
+
+MachOObjectFile::load_command_iterator
+MachOObjectFile::end_load_commands() const {
+  return LoadCommands.end();
+}
+
+iterator_range<MachOObjectFile::load_command_iterator>
+MachOObjectFile::load_commands() const {
+  return iterator_range<load_command_iterator>(begin_load_commands(),
+                                               end_load_commands());
+}
+
 StringRef
 MachOObjectFile::getSectionFinalSegmentName(DataRefImpl Sec) const {
   ArrayRef<char> Raw = getSectionRawFinalSegmentName(Sec);
   return parseSegmentOrSectionName(Raw.data());
 }
 
 ArrayRef<char>
 MachOObjectFile::getSectionRawName(DataRefImpl Sec) const {

tools/llvm-objdump/MachODump.cpp

case MachO::DICE_KIND_ABS_JUMP_TABLE32:
     else
       outs() << "\t@ KIND_ABS_JUMP_TABLE32\n";
     Size = 4;
     break;
   }
   return Size;
 }
 
-static void getSectionsAndSymbols(const MachO::mach_header Header,
-                                  MachOObjectFile *MachOObj,
+static void getSectionsAndSymbols(MachOObjectFile *MachOObj,
                                   std::vector<SectionRef> &Sections,
                                   std::vector<SymbolRef> &Symbols,
                                   SmallVectorImpl<uint64_t> &FoundFns,
                                   uint64_t &BaseSegmentAddress) {
   for (const SymbolRef &Symbol : MachOObj->symbols()) {
     StringRef SymName;
     Symbol.getName(SymName);
     if (!SymName.startswith("ltmp"))
       Symbols.push_back(Symbol);
   }
 
   for (const SectionRef &Section : MachOObj->sections()) {
     StringRef SectName;
     Section.getName(SectName);
     Sections.push_back(Section);
   }
 
-  MachOObjectFile::LoadCommandInfo Command =
-      MachOObj->getFirstLoadCommandInfo();
   bool BaseSegmentAddressSet = false;
-  for (unsigned i = 0;; ++i) {
+  for (const auto &Command : MachOObj->load_commands()) {
     if (Command.C.cmd == MachO::LC_FUNCTION_STARTS) {
       // We found a function starts segment, parse the addresses for later
       // consumption.
       MachO::linkedit_data_command LLC =
           MachOObj->getLinkeditDataLoadCommand(Command);
 
       MachOObj->ReadULEB128s(LLC.dataoff, FoundFns);
     } else if (Command.C.cmd == MachO::LC_SEGMENT) {
       MachO::segment_command SLC = MachOObj->getSegmentLoadCommand(Command);
       StringRef SegName = SLC.segname;
       if (!BaseSegmentAddressSet && SegName != "__PAGEZERO") {
         BaseSegmentAddressSet = true;
         BaseSegmentAddress = SLC.vmaddr;
       }
     }
-
-    if (i == Header.ncmds - 1)
-      break;
-    else
-      Command = MachOObj->getNextLoadCommandInfo(Command);
   }
 }
 
 static void PrintIndirectSymbolTable(MachOObjectFile *O, bool verbose,
                                      uint32_t n, uint32_t count,
                                      uint32_t stride, uint64_t addr) {
   MachO::dysymtab_command Dysymtab = O->getDysymtabLoadCommand();
   uint32_t nindirectsyms = Dysymtab.nindirectsyms;
if (verbose) {
         outs() << "?";
       }
     }
     outs() << "\n";
   }
 }
 
 static void PrintIndirectSymbols(MachOObjectFile *O, bool verbose) {
-  uint32_t LoadCommandCount = O->getHeader().ncmds;
-  MachOObjectFile::LoadCommandInfo Load = O->getFirstLoadCommandInfo();
-  for (unsigned I = 0;; ++I) {
+  for (const auto &Load : O->load_commands()) {
     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
       MachO::segment_command_64 Seg = O->getSegment64LoadCommand(Load);
       for (unsigned J = 0; J < Seg.nsects; ++J) {
         MachO::section_64 Sec = O->getSection64(Load, J);
         uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
         if (section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
             section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
             section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
if (Load.C.cmd == MachO::LC_SEGMENT_64) {
           uint32_t count = Sec.size / stride;
           outs() << "Indirect symbols for (" << Sec.segname << ","
                  << Sec.sectname << ") " << count << " entries";
           uint32_t n = Sec.reserved1;
           PrintIndirectSymbolTable(O, verbose, n, count, stride, Sec.addr);
         }
       }
     }
-    if (I == LoadCommandCount - 1)
-      break;
-    else
-      Load = O->getNextLoadCommandInfo(Load);
   }
 }
 
 static void PrintDataInCodeTable(MachOObjectFile *O, bool verbose) {
   MachO::linkedit_data_command DIC = O->getDataInCodeLoadCommand();
   uint32_t nentries = DIC.datasize / sizeof(struct MachO::data_in_code_entry);
   outs() << "Data in code table (" << nentries << " entries)\n";
   outs() << "offset     length kind\n";
for (uint32_t j = 0; j < narguments; j++) {
       outs() << "\tvalue " << format("0x%" PRIx64, value) << "\n";
       if (i >= nloh)
         return;
     }
   }
 }
 
 static void PrintDylibs(MachOObjectFile *O, bool JustId) {
-  uint32_t LoadCommandCount = O->getHeader().ncmds;
-  MachOObjectFile::LoadCommandInfo Load = O->getFirstLoadCommandInfo();
-  for (unsigned I = 0;; ++I) {
+  unsigned Index = 0;
+  for (const auto &Load : O->load_commands()) {
     if ((JustId && Load.C.cmd == MachO::LC_ID_DYLIB) ||
         (!JustId && (Load.C.cmd == MachO::LC_ID_DYLIB ||
                      Load.C.cmd == MachO::LC_LOAD_DYLIB ||
                      Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB ||
                      Load.C.cmd == MachO::LC_REEXPORT_DYLIB ||
                      Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB ||
                      Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB))) {
       MachO::dylib_command dl = O->getDylibIDLoadCommand(Load);
if ((JustId && Load.C.cmd == MachO::LC_ID_DYLIB) ||
         else if (Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB)
           outs() << "LC_LAZY_LOAD_DYLIB ";
         else if (Load.C.cmd == MachO::LC_REEXPORT_DYLIB)
           outs() << "LC_REEXPORT_DYLIB ";
         else if (Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB)
           outs() << "LC_LOAD_UPWARD_DYLIB ";
         else
           outs() << "LC_??? ";
-        outs() << "command " << I << "\n";
+        outs() << "command " << Index++ << "\n";
       }
     }
-    if (I == LoadCommandCount - 1)
-      break;
-    else
-      Load = O->getNextLoadCommandInfo(Load);
   }
 }
 
 typedef DenseMap<uint64_t, StringRef> SymbolAddressMap;
 
 static void CreateSymbolAddressMap(MachOObjectFile *O,
                                    SymbolAddressMap *AddrMap) {
   // Create a map of symbol addresses to symbol names.
static int SymbolizerGetOpInfo(void *DisInfo, uint64_t Pc, uint64_t Offset,
   return 0;
 }
 
 // GuessCstringPointer is passed the address of what might be a pointer to a
 // literal string in a cstring section.  If that address is in a cstring section
 // it returns a pointer to that string.  Else it returns nullptr.
 static const char *GuessCstringPointer(uint64_t ReferenceValue,
                                        struct DisassembleInfo *info) {
-  uint32_t LoadCommandCount = info->O->getHeader().ncmds;
-  MachOObjectFile::LoadCommandInfo Load = info->O->getFirstLoadCommandInfo();
-  for (unsigned I = 0;; ++I) {
+  for (const auto &Load : info->O->load_commands()) {
     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
       MachO::segment_command_64 Seg = info->O->getSegment64LoadCommand(Load);
       for (unsigned J = 0; J < Seg.nsects; ++J) {
         MachO::section_64 Sec = info->O->getSection64(Load, J);
         uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
         if (section_type == MachO::S_CSTRING_LITERALS &&
             ReferenceValue >= Sec.addr &&
             ReferenceValue < Sec.addr + Sec.size) {
if (Load.C.cmd == MachO::LC_SEGMENT_64) {
             const char *name = object_addr + object_offset;
             return name;
           } else {
             return nullptr;
           }
         }
       }
     }
-    if (I == LoadCommandCount - 1)
-      break;
-    else
-      Load = info->O->getNextLoadCommandInfo(Load);
   }
   return nullptr;
 }
 
 // GuessIndirectSymbol returns the name of the indirect symbol for the
 // ReferenceValue passed in or nullptr.  This is used when ReferenceValue maybe
 // an address of a symbol stub or a lazy or non-lazy pointer to associate the
 // symbol name being referenced by the stub or pointer.
 static const char *GuessIndirectSymbol(uint64_t ReferenceValue,
                                        struct DisassembleInfo *info) {
-  uint32_t LoadCommandCount = info->O->getHeader().ncmds;
-  MachOObjectFile::LoadCommandInfo Load = info->O->getFirstLoadCommandInfo();
   MachO::dysymtab_command Dysymtab = info->O->getDysymtabLoadCommand();
   MachO::symtab_command Symtab = info->O->getSymtabLoadCommand();
-  for (unsigned I = 0;; ++I) {
+  for (const auto &Load : info->O->load_commands()) {
     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
       MachO::segment_command_64 Seg = info->O->getSegment64LoadCommand(Load);
       for (unsigned J = 0; J < Seg.nsects; ++J) {
         MachO::section_64 Sec = info->O->getSection64(Load, J);
         uint32_t section_type = Sec.flags & MachO::SECTION_TYPE;
         if ((section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS ||
              section_type == MachO::S_LAZY_SYMBOL_POINTERS ||
              section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS ||
if (Load.C.cmd == MachO::LC_SEGMENT_64) {
               Symbol.getName(SymName);
               const char *name = SymName.data();
               return name;
             }
           }
         }
       }
     }
-    if (I == LoadCommandCount - 1)
-      break;
-    else
-      Load = info->O->getNextLoadCommandInfo(Load);
   }
   return nullptr;
 }
 
 // method_reference() is called passing it the ReferenceName that might be
 // a reference it to an Objective-C method call.  If so then it allocates and
 // assembles a method call string with the values last seen and saved in
 // the DisassembleInfo's class_name and selector_name fields.  This is saved

 static uint64_t GuessPointerPointer(uint64_t ReferenceValue,
                                     struct DisassembleInfo *info,
                                     bool &classref, bool &selref, bool &msgref,
                                     bool &cfstring) {
   classref = false;
   selref = false;
   msgref = false;
   cfstring = false;
-  uint32_t LoadCommandCount = info->O->getHeader().ncmds;
-  MachOObjectFile::LoadCommandInfo Load = info->O->getFirstLoadCommandInfo();
-  for (unsigned I = 0;; ++I) {
+  for (const auto &Load : info->O->load_commands()) {
     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
       MachO::segment_command_64 Seg = info->O->getSegment64LoadCommand(Load);
       for (unsigned J = 0; J < Seg.nsects; ++J) {
         MachO::section_64 Sec = info->O->getSection64(Load, J);
         if ((strncmp(Sec.sectname, "__objc_selrefs", 16) == 0 ||
              strncmp(Sec.sectname, "__objc_classrefs", 16) == 0 ||
              strncmp(Sec.sectname, "__objc_superrefs", 16) == 0 ||
              strncmp(Sec.sectname, "__objc_msgrefs", 16) == 0 ||
if (Load.C.cmd == MachO::LC_SEGMENT_64) {
             return pointer_value;
           } else {
             return 0;
           }
         }
       }
     }
     // TODO: Look for LC_SEGMENT for 32-bit Mach-O files.
-    if (I == LoadCommandCount - 1)
-      break;
-    else
-      Load = info->O->getNextLoadCommandInfo(Load);
   }
   return 0;
 }
 
 // get_pointer_64 returns a pointer to the bytes in the object file at the
 // Address from a section in the Mach-O file.  And indirectly returns the
 // offset into the section, number of bytes left in the section past the offset
 // and which section is was being referenced.  If the Address is not in a
static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
   // annotate relocations with the referenced symbol's name, and if this was
   // inside a __[cf]string section, the data it points to. This is now replaced
   // by the upcoming MCSymbolizer, which needs the appropriate setup done above.
   std::vector<SectionRef> Sections;
   std::vector<SymbolRef> Symbols;
   SmallVector<uint64_t, 8> FoundFns;
   uint64_t BaseSegmentAddress;
 
-  getSectionsAndSymbols(Header, MachOOF, Sections, Symbols, FoundFns,
+  getSectionsAndSymbols(MachOOF, Sections, Symbols, FoundFns,
                         BaseSegmentAddress);
 
   // Sort the symbols by address, just in case they didn't come in that way.
   std::sort(Symbols.begin(), Symbols.end(), SymbolSorter());
 
   // Build a data in code table that is sorted on by the address of each entry.
   uint64_t BaseAddress = 0;
   if (Header.filetype == MachO::MH_OBJECT)
static void PrintLinkEditDataCommand(MachO::linkedit_data_command ld,
   uint64_t big_size = ld.dataoff;
   big_size += ld.datasize;
   if (big_size > object_size)
     outs() << " (past end of file)\n";
   else
     outs() << "\n";
 }
 
-static void PrintLoadCommands(const MachOObjectFile *Obj, uint32_t ncmds,
-                              uint32_t filetype, uint32_t cputype,
-                              bool verbose) {
-  if (ncmds == 0)
-    return;
+static void PrintLoadCommands(const MachOObjectFile *Obj, uint32_t filetype,
+                              uint32_t cputype, bool verbose) {
   StringRef Buf = Obj->getData();
-  MachOObjectFile::LoadCommandInfo Command = Obj->getFirstLoadCommandInfo();
-  for (unsigned i = 0;; ++i) {
-    outs() << "Load command " << i << "\n";
+  unsigned Index = 0;
+  for (const auto &Command : Obj->load_commands()) {
+    outs() << "Load command " << Index++ << "\n";
     if (Command.C.cmd == MachO::LC_SEGMENT) {
       MachO::segment_command SLC = Obj->getSegmentLoadCommand(Command);
       const char *sg_segname = SLC.segname;
       PrintSegmentCommand(SLC.cmd, SLC.cmdsize, SLC.segname, SLC.vmaddr,
                           SLC.vmsize, SLC.fileoff, SLC.filesize, SLC.maxprot,
                           SLC.initprot, SLC.nsects, SLC.flags, Buf.size(),
                           verbose);
       for (unsigned j = 0; j < SLC.nsects; j++) {
if (Command.C.cmd == MachO::LC_SEGMENT) {
       PrintLinkEditDataCommand(Ld, Buf.size());
     } else {
       outs() << "      cmd ?(" << format("0x%08" PRIx32, Command.C.cmd)
              << ")\n";
       outs() << "  cmdsize " << Command.C.cmdsize << "\n";
       // TODO: get and print the raw bytes of the load command.
     }
     // TODO: print all the other kinds of load commands.
-    if (i == ncmds - 1)
-      break;
-    else
-      Command = Obj->getNextLoadCommandInfo(Command);
   }
 }
 
-static void getAndPrintMachHeader(const MachOObjectFile *Obj, uint32_t &ncmds,
+static void getAndPrintMachHeader(const MachOObjectFile *Obj,
                                   uint32_t &filetype, uint32_t &cputype,
                                   bool verbose) {
   if (Obj->is64Bit()) {
     MachO::mach_header_64 H_64;
     H_64 = Obj->getHeader64();
     PrintMachHeader(H_64.magic, H_64.cputype, H_64.cpusubtype, H_64.filetype,
                     H_64.ncmds, H_64.sizeofcmds, H_64.flags, verbose);
-    ncmds = H_64.ncmds;
     filetype = H_64.filetype;
     cputype = H_64.cputype;
   } else {
     MachO::mach_header H;
     H = Obj->getHeader();
     PrintMachHeader(H.magic, H.cputype, H.cpusubtype, H.filetype, H.ncmds,
                     H.sizeofcmds, H.flags, verbose);
-    ncmds = H.ncmds;
     filetype = H.filetype;
     cputype = H.cputype;
   }
 }
 
 void llvm::printMachOFileHeader(const object::ObjectFile *Obj) {
   const MachOObjectFile *file = dyn_cast<const MachOObjectFile>(Obj);
-  uint32_t ncmds = 0;
   uint32_t filetype = 0;
   uint32_t cputype = 0;
-  getAndPrintMachHeader(file, ncmds, filetype, cputype, !NonVerbose);
-  PrintLoadCommands(file, ncmds, filetype, cputype, !NonVerbose);
+  getAndPrintMachHeader(file, filetype, cputype, !NonVerbose);
+  PrintLoadCommands(file, filetype, cputype, !NonVerbose);
 }
 
 //===----------------------------------------------------------------------===//
 // export trie dumping
 //===----------------------------------------------------------------------===//
 
 void llvm::printMachOExportsTrie(const object::MachOObjectFile *Obj) {
   for (const llvm::object::ExportEntry &Entry : Obj->exports()) {

tools/llvm-size/llvm-size.cpp

 static void PrintDarwinSectionSizes(MachOObjectFile *MachO) {
   std::string fmtbuf;
   raw_string_ostream fmt(fmtbuf);
   const char *radix_fmt = getRadixFmt();
   if (Radix == hexadecimal)
     fmt << "0x";
   fmt << "%" << radix_fmt;
 
-  uint32_t LoadCommandCount = MachO->getHeader().ncmds;
   uint32_t Filetype = MachO->getHeader().filetype;
-  MachOObjectFile::LoadCommandInfo Load = MachO->getFirstLoadCommandInfo();
 
   uint64_t total = 0;
-  for (unsigned I = 0;; ++I) {
+  for (const auto &Load : MachO->load_commands()) {
     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
       MachO::segment_command_64 Seg = MachO->getSegment64LoadCommand(Load);
       outs() << "Segment " << Seg.segname << ": "
              << format(fmt.str().c_str(), Seg.vmsize);
       if (DarwinLongFormat)
         outs() << " (vmaddr 0x" << format("%" PRIx64, Seg.vmaddr) << " fileoff "
                << Seg.fileoff << ")";
       outs() << "\n";
if (Load.C.cmd == MachO::LC_SEGMENT_64) {
           outs() << " (addr 0x" << format("%" PRIx64, Sec.addr) << " offset "
                  << Sec.offset << ")";
         outs() << "\n";
         sec_total += Sec.size;
       }
       if (Seg.nsects != 0)
         outs() << "\ttotal " << format(fmt.str().c_str(), sec_total) << "\n";
     }
-    if (I == LoadCommandCount - 1)
-      break;
-    else
-      Load = MachO->getNextLoadCommandInfo(Load);
   }
   outs() << "total " << format(fmt.str().c_str(), total) << "\n";
 }
 
 /// @brief Print the summary sizes of the standard Mach-O segments in @p MachO.
 ///
 /// This is when used when @c OutputFormat is berkeley with a Mach-O file and
 /// produces the same output as darwin's size(1) default output.
 static void PrintDarwinSegmentSizes(MachOObjectFile *MachO) {
-  uint32_t LoadCommandCount = MachO->getHeader().ncmds;
-  MachOObjectFile::LoadCommandInfo Load = MachO->getFirstLoadCommandInfo();
-
   uint64_t total_text = 0;
   uint64_t total_data = 0;
   uint64_t total_objc = 0;
   uint64_t total_others = 0;
-  for (unsigned I = 0;; ++I) {
+  for (const auto &Load : MachO->load_commands()) {
     if (Load.C.cmd == MachO::LC_SEGMENT_64) {
       MachO::segment_command_64 Seg = MachO->getSegment64LoadCommand(Load);
       if (MachO->getHeader().filetype == MachO::MH_OBJECT) {
         for (unsigned J = 0; J < Seg.nsects; ++J) {
           MachO::section_64 Sec = MachO->getSection64(Load, J);
           StringRef SegmentName = StringRef(Sec.segname);
           if (SegmentName == "__TEXT")
             total_text += Sec.size;
if (Load.C.cmd == MachO::LC_SEGMENT_64) {
         else if (SegmentName == "__DATA")
           total_data += Seg.vmsize;
         else if (SegmentName == "__OBJC")
           total_objc += Seg.vmsize;
         else
           total_others += Seg.vmsize;
       }
     }
-    if (I == LoadCommandCount - 1)
-      break;
-    else
-      Load = MachO->getNextLoadCommandInfo(Load);
   }
   uint64_t total = total_text + total_data + total_objc + total_others;
 
   if (!berkeleyHeaderPrinted) {
     outs() << "__TEXT\t__DATA\t__OBJC\tothers\tdec\thex\n";
     berkeleyHeaderPrinted = true;
   }
   outs() << total_text << "\t" << total_data << "\t" << total_objc << "\t"

tools/macho-dump/macho-dump.cpp

DumpDylibID(const MachOObjectFile &Obj,
   outs() << "  ('install_name', '" << LCI.Ptr + DLLC.dylib.name << "')\n"
          << "  ('timestamp, " << DLLC.dylib.timestamp << ")\n"
          << "  ('cur_version, " << DLLC.dylib.current_version << ")\n"
          << "  ('compat_version, " << DLLC.dylib.compatibility_version << ")\n";
   return 0;
 }
 
 static int DumpLoadCommand(const MachOObjectFile &Obj,
-                           MachOObjectFile::LoadCommandInfo &LCI) {
+                           const MachOObjectFile::LoadCommandInfo &LCI) {
   switch (LCI.C.cmd) {
   case MachO::LC_SEGMENT:
     return DumpSegmentCommand(Obj, LCI);
   case MachO::LC_SEGMENT_64:
     return DumpSegment64Command(Obj, LCI);
   case MachO::LC_SYMTAB:
     return DumpSymtabCommand(Obj);
   case MachO::LC_DYSYMTAB:
static int DumpLoadCommand(const MachOObjectFile &Obj,
   case MachO::LC_ID_DYLIB:
     return DumpDylibID(Obj, LCI);
   default:
     Warning("unknown load command: " + Twine(LCI.C.cmd));
     return 0;
   }
 }
 
-
 static int DumpLoadCommand(const MachOObjectFile &Obj, unsigned Index,
-                           MachOObjectFile::LoadCommandInfo &LCI) {
+                           const MachOObjectFile::LoadCommandInfo &LCI) {
   outs() << "  # Load Command " << Index << "\n"
          << " (('command', " << LCI.C.cmd << ")\n"
          << "  ('size', " << LCI.C.cmdsize << ")\n";
   int Res = DumpLoadCommand(Obj, LCI);
   outs() << " ),\n";
   return Res;
 }
 
int main(int argc, char **argv) {
   if (InputObject->is64Bit())
     Header64 = InputObject->getHeader64();
   else
     *Header = InputObject->getHeader();
   printHeader(InputObject, *Header);
 
   // Print the load commands.
   int Res = 0;
-  MachOObjectFile::LoadCommandInfo Command =
-    InputObject->getFirstLoadCommandInfo();
+  unsigned Index = 0;
   outs() << "('load_commands', [\n";
-  for (unsigned i = 0; ; ++i) {
-    if (DumpLoadCommand(*InputObject, i, Command))
-      break;
-
-    if (i == Header->ncmds - 1)
+  for (const auto &Load : InputObject->load_commands()) {
+    if (DumpLoadCommand(*InputObject, Index++, Load))
       break;
-    Command = InputObject->getNextLoadCommandInfo(Command);
   }
   outs() << "])\n";
 
   return Res;
 }