[Object, MachO] Make MachO parser significantly more robust to invalid inputs.

[samsonov]

Summary

In general, assume that parsing MachO command may fail: make a large
family of methods return std::error_code instead of returning MachO
commands by value.

This is a significant API change. For now I've just converted MachO
parser implementation, and will proceed with converting the callers if
this direction is approved.

This change is a part of ongoing effort to use LibFuzzer to test LLVM
object parsing/dumping machinery, see r238451 that adds
llvm-dwarfdump-fuzzer, for instance.

[samsonov]

Fix a few typos.

[loladiro]

Would it be sensible to use ErrorOr instead of adding an out parameter?

[samsonov]

In D10111#180753, @loladiro wrote:

Would it be sensible to use ErrorOr instead of adding an out parameter?

std::error_code is consistent with ObjectFile interface. See include/llvm/Object/ObjectFile.h: we use std::error_code in accessors like ObjectFile::getSymbolAddress(), and only use ErrorOr in factories.

[loladiro]

I don't really have a strong opinion either way, I just wanted to bring it up as last time I touched this file a strong preference for moving everything to ErrorOr was expressed in the review, because it's easy to ignore the std::error_code.

include/llvm/Object/MachO.h

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;
 
   // MachO specific.
   std::error_code getIndirectName(DataRefImpl Symb, StringRef &Res) const;
-  unsigned getSectionType(SectionRef Sec) const;
+  std::error_code getSectionType(SectionRef Sec, unsigned &Type) const;
 
   std::error_code getSymbolAddress(DataRefImpl Symb,
                                    uint64_t &Res) const override;
   std::error_code getSymbolAlignment(DataRefImpl Symb,
                                      uint32_t &Res) const override;
   std::error_code getSymbolSize(DataRefImpl Symb, uint64_t &Res) const override;
   std::error_code getSymbolType(DataRefImpl Symb,
                                 SymbolRef::Type &Res) const override;
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;
+  std::error_code getFirstLoadCommandInfo(LoadCommandInfo &Load) const;
+  std::error_code getNextLoadCommandInfo(const LoadCommandInfo &L,
+                                         LoadCommandInfo &Next) 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;
-
-  MachO::linkedit_data_command
-  getLinkeditDataLoadCommand(const LoadCommandInfo &L) const;
-  MachO::segment_command
-  getSegmentLoadCommand(const LoadCommandInfo &L) const;
-  MachO::segment_command_64
-  getSegment64LoadCommand(const LoadCommandInfo &L) const;
-  MachO::linker_option_command
-  getLinkerOptionLoadCommand(const LoadCommandInfo &L) const;
-  MachO::version_min_command
-  getVersionMinLoadCommand(const LoadCommandInfo &L) const;
-  MachO::dylib_command
-  getDylibIDLoadCommand(const LoadCommandInfo &L) const;
-  MachO::dyld_info_command
-  getDyldInfoLoadCommand(const LoadCommandInfo &L) const;
-  MachO::dylinker_command
-  getDylinkerCommand(const LoadCommandInfo &L) const;
-  MachO::uuid_command
-  getUuidCommand(const LoadCommandInfo &L) const;
-  MachO::rpath_command
-  getRpathCommand(const LoadCommandInfo &L) const;
-  MachO::source_version_command
-  getSourceVersionCommand(const LoadCommandInfo &L) const;
-  MachO::entry_point_command
-  getEntryPointCommand(const LoadCommandInfo &L) const;
-  MachO::encryption_info_command
-  getEncryptionInfoCommand(const LoadCommandInfo &L) const;
-  MachO::encryption_info_command_64
-  getEncryptionInfoCommand64(const LoadCommandInfo &L) const;
-  MachO::sub_framework_command
-  getSubFrameworkCommand(const LoadCommandInfo &L) const;
-  MachO::sub_umbrella_command
-  getSubUmbrellaCommand(const LoadCommandInfo &L) const;
-  MachO::sub_library_command
-  getSubLibraryCommand(const LoadCommandInfo &L) const;
-  MachO::sub_client_command
-  getSubClientCommand(const LoadCommandInfo &L) const;
-  MachO::routines_command
-  getRoutinesCommand(const LoadCommandInfo &L) const;
-  MachO::routines_command_64
-  getRoutinesCommand64(const LoadCommandInfo &L) const;
-  MachO::thread_command
-  getThreadCommand(const LoadCommandInfo &L) const;
-
-  MachO::any_relocation_info getRelocation(DataRefImpl Rel) const;
-  MachO::data_in_code_entry getDice(DataRefImpl Rel) const;
-  MachO::mach_header getHeader() const;
-  MachO::mach_header_64 getHeader64() const;
-  uint32_t
+  std::error_code getSection(DataRefImpl DRI, MachO::section &Section) const;
+  std::error_code getSection64(DataRefImpl DRI,
+                               MachO::section_64 &Section) const;
+  std::error_code getSection(const LoadCommandInfo &L, unsigned Index,
+                             MachO::section &Section) const;
+  std::error_code getSection64(const LoadCommandInfo &L, unsigned Index,
+                               MachO::section_64 &Section) const;
+  std::error_code getSymbolTableEntry(DataRefImpl DRI,
+                                      MachO::nlist &Nlist) const;
+  std::error_code getSymbol64TableEntry(DataRefImpl DRI,
+                                        MachO::nlist_64 &Nlist) const;
+
+  std::error_code
+  getLinkeditDataLoadCommand(const LoadCommandInfo &L,
+                             MachO::linkedit_data_command &Cmd) const;
+  std::error_code getSegmentLoadCommand(const LoadCommandInfo &L,
+                                        MachO::segment_command &Cmd) const;
+  std::error_code getSegment64LoadCommand(const LoadCommandInfo &L,
+                                          MachO::segment_command_64 &Cmd) const;
+  std::error_code
+  getLinkerOptionLoadCommand(const LoadCommandInfo &L,
+                             MachO::linker_option_command &Cmd) const;
+  std::error_code
+  getVersionMinLoadCommand(const LoadCommandInfo &L,
+                           MachO::version_min_command &Cmd) const;
+  std::error_code getDylibIDLoadCommand(const LoadCommandInfo &L,
+                                        MachO::dylib_command &Cmd) const;
+  std::error_code getDyldInfoLoadCommand(const LoadCommandInfo &L,
+                                         MachO::dyld_info_command &Cmd) const;
+  std::error_code getDylinkerCommand(const LoadCommandInfo &L,
+                                     MachO::dylinker_command &Cmd) const;
+  std::error_code getUuidCommand(const LoadCommandInfo &L,
+                                 MachO::uuid_command &Cmd) const;
+  std::error_code getRpathCommand(const LoadCommandInfo &L,
+                                  MachO::rpath_command &Cmd) const;
+  std::error_code
+  getSourceVersionCommand(const LoadCommandInfo &L,
+                          MachO::source_version_command &Cmd) const;
+  std::error_code getEntryPointCommand(const LoadCommandInfo &L,
+                                       MachO::entry_point_command &Cmd) const;
+  std::error_code
+  getEncryptionInfoCommand(const LoadCommandInfo &L,
+                           MachO::encryption_info_command &Cmd) const;
+  std::error_code
+  getEncryptionInfoCommand64(const LoadCommandInfo &L,
+                             MachO::encryption_info_command_64 &Cmd) const;
+  std::error_code
+  getSubFrameworkCommand(const LoadCommandInfo &L,
+                         MachO::sub_framework_command &Cmd) const;
+  std::error_code getSubUmbrellaCommand(const LoadCommandInfo &L,
+                                        MachO::sub_umbrella_command &Cmd) const;
+  std::error_code getSubLibraryCommand(const LoadCommandInfo &L,
+                                       MachO::sub_library_command &Cmd) const;
+  std::error_code getSubClientCommand(const LoadCommandInfo &L,
+                                      MachO::sub_client_command &Cmd) const;
+  std::error_code getRoutinesCommand(const LoadCommandInfo &L,
+                                     MachO::routines_command &Cmd) const;
+  std::error_code getRoutinesCommand64(const LoadCommandInfo &L,
+                                       MachO::routines_command_64 &Cmd) const;
+  std::error_code getThreadCommand(const LoadCommandInfo &L,
+                                   MachO::thread_command &Cmd) const;
+
+  std::error_code getRelocation(DataRefImpl Rel,
+                                MachO::any_relocation_info &RelInfo) const;
+  std::error_code getDice(DataRefImpl Rel, MachO::data_in_code_entry &Dice) const;
+  std::error_code getHeader(MachO::mach_header &Header) const;
+  std::error_code getHeader64(MachO::mach_header_64 &Header) const;
+  std::error_code
   getIndirectSymbolTableEntry(const MachO::dysymtab_command &DLC,
-                              unsigned Index) const;
-  MachO::data_in_code_entry getDataInCodeTableEntry(uint32_t DataOffset,
-                                                    unsigned Index) const;
-  MachO::symtab_command getSymtabLoadCommand() const;
-  MachO::dysymtab_command getDysymtabLoadCommand() const;
-  MachO::linkedit_data_command getDataInCodeLoadCommand() const;
-  MachO::linkedit_data_command getLinkOptHintsLoadCommand() const;
+                              unsigned Index, uint32_t &Res) const;
+  std::error_code
+  getDataInCodeTableEntry(uint32_t DataOffset, unsigned Index,
+                          MachO::data_in_code_entry &Dice) const;
+  std::error_code getSymtabLoadCommand(MachO::symtab_command &Cmd) const;
+  std::error_code getDysymtabLoadCommand(MachO::dysymtab_command &Cmd) const;
+  std::error_code
+  getDataInCodeLoadCommand(MachO::linkedit_data_command &Cmd) const;
+  std::error_code
+  getLinkOptHintsLoadCommand(MachO::linkedit_data_command &Cmd) const;
+
   ArrayRef<uint8_t> getDyldInfoRebaseOpcodes() const;
   ArrayRef<uint8_t> getDyldInfoBindOpcodes() const;
   ArrayRef<uint8_t> getDyldInfoWeakBindOpcodes() const;
   ArrayRef<uint8_t> getDyldInfoLazyBindOpcodes() const;
   ArrayRef<uint8_t> getDyldInfoExportsTrie() const;
   ArrayRef<uint8_t> getUuid() const;
 
-  StringRef getStringTableData() const;
+  std::error_code getStringTableData(StringRef &Res) const;
   bool is64Bit() const;
   void ReadULEB128s(uint64_t Index, SmallVectorImpl<uint64_t> &Out) const;
 
   static StringRef guessLibraryShortName(StringRef Name, bool &isFramework,
                                          StringRef &Suffix);
 
   static Triple::ArchType getArch(uint32_t CPUType);
   static Triple getArch(uint32_t CPUType, uint32_t CPUSubType,

 
 // Since a Mach-O data in code reference, a DiceRef, can only be created when
 // the OwningObject ObjectFile is a MachOObjectFile a static_cast<> is used for
 // the methods that get the values of the fields of the reference.
 
 inline std::error_code DiceRef::getOffset(uint32_t &Result) const {
   const MachOObjectFile *MachOOF =
     static_cast<const MachOObjectFile *>(OwningObject);
-  MachO::data_in_code_entry Dice = MachOOF->getDice(DicePimpl);
+  MachO::data_in_code_entry Dice;
+  if (auto Err = MachOOF->getDice(DicePimpl, Dice))
+    return Err;
   Result = Dice.offset;
   return object_error::success;
 }
 
 inline std::error_code DiceRef::getLength(uint16_t &Result) const {
   const MachOObjectFile *MachOOF =
     static_cast<const MachOObjectFile *>(OwningObject);
-  MachO::data_in_code_entry Dice = MachOOF->getDice(DicePimpl);
+  MachO::data_in_code_entry Dice;
+  if (auto Err = MachOOF->getDice(DicePimpl, Dice))
+    return Err;
   Result = Dice.length;
   return object_error::success;
 }
 
 inline std::error_code DiceRef::getKind(uint16_t &Result) const {
   const MachOObjectFile *MachOOF =
     static_cast<const MachOObjectFile *>(OwningObject);
-  MachO::data_in_code_entry Dice = MachOOF->getDice(DicePimpl);
+  MachO::data_in_code_entry Dice;
+  if (auto Err = MachOOF->getDice(DicePimpl, Dice))
+    return Err;
   Result = Dice.kind;
   return object_error::success;
 }
 
 inline DataRefImpl DiceRef::getRawDataRefImpl() const {
   return DicePimpl;
 }
 

lib/Object/MachOObjectFile.cpp

 namespace {
   struct section_base {
     char sectname[16];
     char segname[16];
   };
 }
 
 template <typename T>
-static T getStruct(const MachOObjectFile *O, const char *P) {
+static std::error_code getStruct(const MachOObjectFile *O, const char *P,
+                                 T &Cmd) {
   // Don't read before the beginning or past the end of the file
   if (P < O->getData().begin() || P + sizeof(T) > O->getData().end())
-    report_fatal_error("Malformed MachO file.");
+    return object_error::parse_failed;
 
-  T Cmd;
   memcpy(&Cmd, P, sizeof(T));
   if (O->isLittleEndian() != sys::IsLittleEndianHost)
     MachO::swapStruct(Cmd);
-  return Cmd;
+  return std::error_code();
 }
 
 template <typename SegmentCmd>
-static uint32_t getSegmentLoadCommandNumSections(const SegmentCmd &S,
-                                                 uint32_t Cmdsize) {
+static std::error_code getSegmentLoadCommandNumSections(const SegmentCmd &S,
+                                                        uint32_t Cmdsize,
+                                                        uint32_t &NumSections) {
   const unsigned SectionSize = sizeof(SegmentCmd);
+  // Number of sections too large for size of load command.
   if (S.nsects > std::numeric_limits<uint32_t>::max() / SectionSize ||
       S.nsects * SectionSize > Cmdsize - sizeof(S))
-    report_fatal_error(
-        "Number of sections too large for size of load command.");
-  return S.nsects;
+    return object_error::parse_failed;
+  NumSections = S.nsects;
+  return std::error_code();
 }
 
-static uint32_t
+static std::error_code
 getSegmentLoadCommandNumSections(const MachOObjectFile *O,
-                                 const MachOObjectFile::LoadCommandInfo &L) {
-  if (O->is64Bit())
-    return getSegmentLoadCommandNumSections(O->getSegment64LoadCommand(L),
-                                            L.C.cmdsize);
+                                 const MachOObjectFile::LoadCommandInfo &L,
+                                 uint32_t &NumSections) {
+  if (O->is64Bit()) {
+    MachO::segment_command_64 Cmd;
+    if (auto Err = O->getSegment64LoadCommand(L, Cmd))
+      return Err;
+    return getSegmentLoadCommandNumSections(Cmd, L.C.cmdsize, NumSections);
+  }
 
-  return getSegmentLoadCommandNumSections(O->getSegmentLoadCommand(L),
-                                          L.C.cmdsize);
+  MachO::segment_command Cmd;
+  if (auto Err = O->getSegmentLoadCommand(L, Cmd))
+    return Err;
+  return getSegmentLoadCommandNumSections(Cmd, L.C.cmdsize, NumSections);
 }
 
 static bool isPageZeroSegment(const MachOObjectFile *O,
                               const MachOObjectFile::LoadCommandInfo &L) {
   if (O->is64Bit()) {
-    MachO::segment_command_64 S = O->getSegment64LoadCommand(L);
+    MachO::segment_command_64 S;
+    if (O->getSegment64LoadCommand(L, S))
+      return false;
     return StringRef("__PAGEZERO").equals(S.segname);
   }
-  MachO::segment_command S = O->getSegmentLoadCommand(L);
+  MachO::segment_command S;
+  if (O->getSegmentLoadCommand(L, S))
+    return false;
   return StringRef("__PAGEZERO").equals(S.segname);
 }
 
 
 static const char *
 getSectionPtr(const MachOObjectFile *O, MachOObjectFile::LoadCommandInfo L,
               unsigned Sec) {
   uintptr_t CommandAddr = reinterpret_cast<uintptr_t>(L.Ptr);
 
   bool Is64 = O->is64Bit();
   unsigned SegmentLoadSize = Is64 ? sizeof(MachO::segment_command_64) :
                                     sizeof(MachO::segment_command);
   unsigned SectionSize = Is64 ? sizeof(MachO::section_64) :
                                 sizeof(MachO::section);
 
   uintptr_t SectionAddr = CommandAddr + SegmentLoadSize + Sec * SectionSize;
   return reinterpret_cast<const char*>(SectionAddr);
 }
 
 static const char *getPtr(const MachOObjectFile *O, size_t Offset) {
   return O->getData().substr(Offset, 1).data();
 }
 
-static MachO::nlist_base
-getSymbolTableEntryBase(const MachOObjectFile *O, DataRefImpl DRI) {
+static std::error_code getSymbolTableEntryBase(const MachOObjectFile *O,
+                                               DataRefImpl DRI,
+                                               MachO::nlist_base &NlistBase) {
   const char *P = reinterpret_cast<const char *>(DRI.p);
-  return getStruct<MachO::nlist_base>(O, P);
+  return getStruct(O, P, NlistBase);
 }
 
 static StringRef parseSegmentOrSectionName(const char *P) {
   if (P[15] == 0)
     // Null terminated.
     return P;
   // Not null terminated, so this is a 16 char string.
   return StringRef(P, 16);
 }
 
 // Helper to advance a section or symbol iterator multiple increments at a time.
 template<class T>
 static void advance(T &it, size_t Val) {
   while (Val--)
     ++it;
 }
 
-static unsigned getCPUType(const MachOObjectFile *O) {
-  return O->getHeader().cputype;
+static std::error_code getCPUType(const MachOObjectFile *O, unsigned &Res) {
+  MachO::mach_header Header;
+  if (auto Err = O->getHeader(Header))
+    return Err;
+  Res = Header.cputype;
+  return std::error_code();
 }
 
 static void printRelocationTargetName(const MachOObjectFile *O,
                                       const MachO::any_relocation_info &RE,
                                       raw_string_ostream &fmt) {
   bool IsScattered = O->isRelocationScattered(RE);
 
   // Target of a scattered relocation is an address.  In the interest of

 
 static unsigned getPlainRelocationType(const MachOObjectFile *O,
                                        const MachO::any_relocation_info &RE) {
   if (O->isLittleEndian())
     return RE.r_word1 >> 28;
   return RE.r_word1 & 0xf;
 }
 
-static uint32_t getSectionFlags(const MachOObjectFile *O,
-                                DataRefImpl Sec) {
+static std::error_code getSectionFlags(const MachOObjectFile *O,
+                                       DataRefImpl Sec, uint32_t &Flags) {
   if (O->is64Bit()) {
-    MachO::section_64 Sect = O->getSection64(Sec);
-    return Sect.flags;
-  }
-  MachO::section Sect = O->getSection(Sec);
-  return Sect.flags;
+    MachO::section_64 Sect;
+    if (auto Err = O->getSection64(Sec, Sect))
+      return Err;
+    Flags = Sect.flags;
+    return std::error_code();
+  }
+  MachO::section Sect;
+  if (auto Err = O->getSection(Sec, Sect))
+    return Err;
+  Flags = Sect.flags;
+  return std::error_code();
 }
 
 MachOObjectFile::MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian,
                                  bool Is64bits, std::error_code &EC)
     : ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object),
       SymtabLoadCmd(nullptr), DysymtabLoadCmd(nullptr),
       DataInCodeLoadCmd(nullptr), LinkOptHintsLoadCmd(nullptr),
       DyldInfoLoadCmd(nullptr), UuidLoadCmd(nullptr),
       HasPageZeroSegment(false) {
-  uint32_t LoadCommandCount = this->getHeader().ncmds;
+  MachO::mach_header Header;
+  if ((EC = getHeader(Header)))
+    return;
+  uint32_t LoadCommandCount = Header.ncmds;
   if (LoadCommandCount == 0)
     return;
 
   MachO::LoadCommandType SegmentLoadType = is64Bit() ?
     MachO::LC_SEGMENT_64 : MachO::LC_SEGMENT;
 
-  MachOObjectFile::LoadCommandInfo Load = getFirstLoadCommandInfo();
+  MachOObjectFile::LoadCommandInfo Load;
+  if ((EC = getFirstLoadCommandInfo(Load)))
+    return;
   for (unsigned I = 0; ; ++I) {
     if (Load.C.cmd == MachO::LC_SYMTAB) {
       // Multiple symbol tables
       if (SymtabLoadCmd) {
         EC = object_error::parse_failed;
         return;
       }
       SymtabLoadCmd = Load.Ptr;
if (Load.C.cmd == MachO::LC_SYMTAB) {
         EC = object_error::parse_failed;
         return;
       }
       UuidLoadCmd = Load.Ptr;
     } else if (Load.C.cmd == SegmentLoadType) {
       const unsigned SegmentLoadSize = this->is64Bit()
                                            ? sizeof(MachO::segment_command_64)
                                            : sizeof(MachO::segment_command);
-      if (Load.C.cmdsize < SegmentLoadSize)
-        report_fatal_error("Segment load command size is too small.");
-
-      uint32_t NumSections = getSegmentLoadCommandNumSections(this, Load);
+      if (Load.C.cmdsize < SegmentLoadSize) {
+        // Segment load command size is too small.
+        EC = object_error::parse_failed;
+        return;
+      }
+      uint32_t NumSections;
+      if ((EC = getSegmentLoadCommandNumSections(this, Load, NumSections)))
+        return;
       for (unsigned J = 0; J < NumSections; ++J) {
         const char *Sec = getSectionPtr(this, Load, J);
         Sections.push_back(Sec);
       }
       if (isPageZeroSegment(this, Load))
         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
-      Load = getNextLoadCommandInfo(Load);
+    if ((EC = getNextLoadCommandInfo(Load, Load)))
+      return;
   }
 }
 
 void MachOObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
   unsigned SymbolTableEntrySize = is64Bit() ?
     sizeof(MachO::nlist_64) :
     sizeof(MachO::nlist);
   Symb.p += SymbolTableEntrySize;
 }
 
 std::error_code MachOObjectFile::getSymbolName(DataRefImpl Symb,
                                                StringRef &Res) const {
-  StringRef StringTable = getStringTableData();
-  MachO::nlist_base Entry = getSymbolTableEntryBase(this, Symb);
+  StringRef StringTable;
+  if (auto Err = getStringTableData(StringTable))
+    return Err;
+  MachO::nlist_base Entry;
+  if (auto Err = getSymbolTableEntryBase(this, Symb, Entry))
+    return Err;
   const char *Start = &StringTable.data()[Entry.n_strx];
+  // Symbol name entry points before beginning or past end of file.
   if (Start < getData().begin() || Start >= getData().end())
-    report_fatal_error(
-        "Symbol name entry points before beginning or past end of file.");
+    return object_error::parse_failed;
   Res = StringRef(Start);
   return object_error::success;
 }
 
-unsigned MachOObjectFile::getSectionType(SectionRef Sec) const {
+std::error_code MachOObjectFile::getSectionType(SectionRef Sec,
+                                                unsigned &Type) const {
   DataRefImpl DRI = Sec.getRawDataRefImpl();
-  uint32_t Flags = getSectionFlags(this, DRI);
-  return Flags & MachO::SECTION_TYPE;
+  uint32_t Flags;
+  if (auto Err = getSectionFlags(this, DRI, Flags))
+    return Err;
+  Type = Flags & MachO::SECTION_TYPE;
+  return object_error::success;
 }
 
 // getIndirectName() returns the name of the alias'ed symbol who's string table
 // index is in the n_value field.
 std::error_code MachOObjectFile::getIndirectName(DataRefImpl Symb,
                                                  StringRef &Res) const {
-  StringRef StringTable = getStringTableData();
+  StringRef StringTable;
+  if (auto Err = getStringTableData(StringTable))
+    return Err;
   uint64_t NValue;
   if (is64Bit()) {
-    MachO::nlist_64 Entry = getSymbol64TableEntry(Symb);
+    MachO::nlist_64 Entry;
+    if (auto Err = getSymbol64TableEntry(Symb, Entry))
+      return Err;
     NValue = Entry.n_value;
     if ((Entry.n_type & MachO::N_TYPE) != MachO::N_INDR)
       return object_error::parse_failed;
   } else {
-    MachO::nlist Entry = getSymbolTableEntry(Symb);
+    MachO::nlist Entry;
+    if (auto Err = getSymbolTableEntry(Symb, Entry))
+      return Err;
     NValue = Entry.n_value;
     if ((Entry.n_type & MachO::N_TYPE) != MachO::N_INDR)
       return object_error::parse_failed;
   }
   if (NValue >= StringTable.size())
     return object_error::parse_failed;
   const char *Start = &StringTable.data()[NValue];
   Res = StringRef(Start);
   return object_error::success;
 }
 
 std::error_code MachOObjectFile::getSymbolAddress(DataRefImpl Symb,
                                                   uint64_t &Res) const {
   if (is64Bit()) {
-    MachO::nlist_64 Entry = getSymbol64TableEntry(Symb);
+    MachO::nlist_64 Entry;
+    if (auto Err = getSymbol64TableEntry(Symb, Entry))
+      return Err;
     if ((Entry.n_type & MachO::N_TYPE) == MachO::N_UNDF &&
         Entry.n_value == 0)
       Res = UnknownAddressOrSize;
     else
       Res = Entry.n_value;
   } else {
-    MachO::nlist Entry = getSymbolTableEntry(Symb);
+    MachO::nlist Entry;
+    if (auto Err = getSymbolTableEntry(Symb, Entry))
+      return Err;
     if ((Entry.n_type & MachO::N_TYPE) == MachO::N_UNDF &&
         Entry.n_value == 0)
       Res = UnknownAddressOrSize;
     else
       Res = Entry.n_value;
   }
   return object_error::success;
 }
 
 std::error_code MachOObjectFile::getSymbolAlignment(DataRefImpl DRI,
                                                     uint32_t &Result) const {
   uint32_t flags = getSymbolFlags(DRI);
   if (flags & SymbolRef::SF_Common) {
-    MachO::nlist_base Entry = getSymbolTableEntryBase(this, DRI);
+    MachO::nlist_base Entry;
+    if (auto Err = getSymbolTableEntryBase(this, DRI, Entry))
+      return Err;
     Result = 1 << MachO::GET_COMM_ALIGN(Entry.n_desc);
   } else {
     Result = 0;
   }
   return object_error::success;
 }
 
 std::error_code MachOObjectFile::getSymbolSize(DataRefImpl DRI,
                                                uint64_t &Result) const {
   uint64_t Value;
   getSymbolAddress(DRI, Value);
   uint32_t flags = getSymbolFlags(DRI);
   if (flags & SymbolRef::SF_Common)
     Result = Value;
   else
     Result = UnknownAddressOrSize;
   return object_error::success;
 }
 
 std::error_code MachOObjectFile::getSymbolType(DataRefImpl Symb,
                                                SymbolRef::Type &Res) const {
-  MachO::nlist_base Entry = getSymbolTableEntryBase(this, Symb);
+  MachO::nlist_base Entry;
+  if (auto Err = getSymbolTableEntryBase(this, Symb, Entry))
+    return Err;
   uint8_t n_type = Entry.n_type;
 
   Res = SymbolRef::ST_Other;
 
   // If this is a STAB debugging symbol, we can do nothing more.
   if (n_type & MachO::N_STAB) {
     Res = SymbolRef::ST_Debug;
     return object_error::success;
   }
 
   switch (n_type & MachO::N_TYPE) {
     case MachO::N_UNDF :
       Res = SymbolRef::ST_Unknown;
       break;
     case MachO::N_SECT :
       Res = SymbolRef::ST_Function;
       break;
   }
   return object_error::success;
 }
 
 uint32_t MachOObjectFile::getSymbolFlags(DataRefImpl DRI) const {
-  MachO::nlist_base Entry = getSymbolTableEntryBase(this, DRI);
+  MachO::nlist_base Entry;
+  // FIXME: Shouldn't getSymbolFlags() return std::error_code as well?
+  if (getSymbolTableEntryBase(this, DRI, Entry))
+    return 0U;
 
   uint8_t MachOType = Entry.n_type;
   uint16_t MachOFlags = Entry.n_desc;
 
   uint32_t Result = SymbolRef::SF_None;
 
   if ((MachOType & MachO::N_TYPE) == MachO::N_UNDF)
     Result |= SymbolRef::SF_Undefined;
uint32_t MachOObjectFile::getSymbolFlags(DataRefImpl DRI) const {
   if ((MachOType & MachO::N_TYPE) == MachO::N_ABS)
     Result |= SymbolRef::SF_Absolute;
 
   return Result;
 }
 
 std::error_code MachOObjectFile::getSymbolSection(DataRefImpl Symb,
                                                   section_iterator &Res) const {
-  MachO::nlist_base Entry = getSymbolTableEntryBase(this, Symb);
+  MachO::nlist_base Entry;
+  if (auto Err = getSymbolTableEntryBase(this, Symb, Entry))
+    return Err;
   uint8_t index = Entry.n_sect;
 
   if (index == 0) {
     Res = section_end();
   } else {
     DataRefImpl DRI;
     DRI.d.a = index - 1;
+    // Invalid section index.
     if (DRI.d.a >= Sections.size())
-      report_fatal_error("getSymbolSection: Invalid section index.");
+      return object_error::parse_failed;
     Res = section_iterator(SectionRef(DRI, this));
   }
 
   return object_error::success;
 }
 
 void MachOObjectFile::moveSectionNext(DataRefImpl &Sec) const {
   Sec.d.a++;
 }
 
 std::error_code MachOObjectFile::getSectionName(DataRefImpl Sec,
                                                 StringRef &Result) const {
   ArrayRef<char> Raw = getSectionRawName(Sec);
   Result = parseSegmentOrSectionName(Raw.data());
   return object_error::success;
 }
 
 uint64_t MachOObjectFile::getSectionAddress(DataRefImpl Sec) const {
-  if (is64Bit())
-    return getSection64(Sec).addr;
-  return getSection(Sec).addr;
+  if (is64Bit()) {
+    MachO::section_64 Section;
+    if (getSection64(Sec, Section))
+      return UnknownAddressOrSize;
+    return Section.addr;
+  }
+  MachO::section Section;
+  if (getSection(Sec, Section))
+    return UnknownAddressOrSize;
+  return Section.addr;
 }
 
 uint64_t MachOObjectFile::getSectionSize(DataRefImpl Sec) const {
-  if (is64Bit())
-    return getSection64(Sec).size;
-  return getSection(Sec).size;
+  if (is64Bit()) {
+    MachO::section_64 Section;
+    if (getSection64(Sec, Section))
+      return UnknownAddressOrSize;
+    return Section.size;
+  }
+  MachO::section Section;
+  if (getSection(Sec, Section))
+    return UnknownAddressOrSize;
+  return Section.size;
 }
 
 std::error_code MachOObjectFile::getSectionContents(DataRefImpl Sec,
                                                     StringRef &Res) const {
   uint32_t Offset;
   uint64_t Size;
 
   if (is64Bit()) {
-    MachO::section_64 Sect = getSection64(Sec);
+    MachO::section_64 Sect;
+    if (auto Err = getSection64(Sec, Sect))
+      return Err;
     Offset = Sect.offset;
     Size = Sect.size;
   } else {
-    MachO::section Sect = getSection(Sec);
+    MachO::section Sect;
+    if (auto Err = getSection(Sec, Sect))
+      return Err;
     Offset = Sect.offset;
     Size = Sect.size;
   }
 
   Res = this->getData().substr(Offset, Size);
   return object_error::success;
 }
 
 uint64_t MachOObjectFile::getSectionAlignment(DataRefImpl Sec) const {
-  uint32_t Align;
+  uint32_t Align = 0;
   if (is64Bit()) {
-    MachO::section_64 Sect = getSection64(Sec);
+    MachO::section_64 Sect;
+    if (!getSection64(Sec, Sect))
       Align = Sect.align;
   } else {
-    MachO::section Sect = getSection(Sec);
+    MachO::section Sect;
+    if (!getSection(Sec, Sect))
       Align = Sect.align;
   }
 
   return uint64_t(1) << Align;
 }
 
 bool MachOObjectFile::isSectionText(DataRefImpl Sec) const {
-  uint32_t Flags = getSectionFlags(this, Sec);
+  uint32_t Flags;
+  if (getSectionFlags(this, Sec, Flags))
+    return false;
   return Flags & MachO::S_ATTR_PURE_INSTRUCTIONS;
 }
 
 bool MachOObjectFile::isSectionData(DataRefImpl Sec) const {
-  uint32_t Flags = getSectionFlags(this, Sec);
+  uint32_t Flags;
+  if (getSectionFlags(this, Sec, Flags))
+    return false;
   unsigned SectionType = Flags & MachO::SECTION_TYPE;
   return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
          !(SectionType == MachO::S_ZEROFILL ||
            SectionType == MachO::S_GB_ZEROFILL);
 }
 
 bool MachOObjectFile::isSectionBSS(DataRefImpl Sec) const {
-  uint32_t Flags = getSectionFlags(this, Sec);
+  uint32_t Flags;
+  if (getSectionFlags(this, Sec, Flags))
+    return false;
   unsigned SectionType = Flags & MachO::SECTION_TYPE;
   return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
          (SectionType == MachO::S_ZEROFILL ||
           SectionType == MachO::S_GB_ZEROFILL);
 }
 
 bool MachOObjectFile::isSectionVirtual(DataRefImpl Sec) const {
   // FIXME: Unimplemented.
relocation_iterator MachOObjectFile::section_rel_begin(DataRefImpl Sec) const {
   DataRefImpl Ret;
   Ret.d.a = Sec.d.a;
   Ret.d.b = 0;
   return relocation_iterator(RelocationRef(Ret, this));
 }
 
 relocation_iterator
 MachOObjectFile::section_rel_end(DataRefImpl Sec) const {
-  uint32_t Num;
+  uint32_t Num = 0;
   if (is64Bit()) {
-    MachO::section_64 Sect = getSection64(Sec);
+    MachO::section_64 Sect;
+    if (!getSection64(Sec, Sect))
       Num = Sect.nreloc;
   } else {
-    MachO::section Sect = getSection(Sec);
+    MachO::section Sect;
+    if (!getSection(Sec, Sect))
       Num = Sect.nreloc;
   }
 
   DataRefImpl Ret;
   Ret.d.a = Sec.d.a;
   Ret.d.b = Num;
   return relocation_iterator(RelocationRef(Ret, this));
 }
 
std::error_code MachOObjectFile::getRelocationAddress(DataRefImpl Rel,
   Sec.d.a = Rel.d.a;
   uint64_t SecAddress = getSectionAddress(Sec);
   Res = SecAddress + Offset;
   return object_error::success;
 }
 
 std::error_code MachOObjectFile::getRelocationOffset(DataRefImpl Rel,
                                                      uint64_t &Res) const {
-  assert(getHeader().filetype == MachO::MH_OBJECT &&
+  MachO::mach_header Header;
+  if (auto Err = getHeader(Header))
+    return Err;
+  assert(Header.filetype == MachO::MH_OBJECT &&
          "Only implemented for MH_OBJECT");
-  MachO::any_relocation_info RE = getRelocation(Rel);
+  MachO::any_relocation_info RE;
+  if (auto Err = getRelocation(Rel, RE))
+    return Err;
   Res = getAnyRelocationAddress(RE);
   return object_error::success;
 }
 
 symbol_iterator
 MachOObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
-  MachO::any_relocation_info RE = getRelocation(Rel);
-  if (isRelocationScattered(RE))
+  MachO::any_relocation_info RE;
+  if (getRelocation(Rel, RE) || isRelocationScattered(RE))
     return symbol_end();
 
   uint32_t SymbolIdx = getPlainRelocationSymbolNum(RE);
   bool isExtern = getPlainRelocationExternal(RE);
   if (!isExtern)
     return symbol_end();
 
-  MachO::symtab_command S = getSymtabLoadCommand();
+  MachO::symtab_command S;
+  if (getSymtabLoadCommand(S))
+    return symbol_end();
+
   unsigned SymbolTableEntrySize = is64Bit() ?
     sizeof(MachO::nlist_64) :
     sizeof(MachO::nlist);
   uint64_t Offset = S.symoff + SymbolIdx * SymbolTableEntrySize;
   DataRefImpl Sym;
   Sym.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset));
   return symbol_iterator(SymbolRef(Sym, this));
 }
 
 section_iterator
 MachOObjectFile::getRelocationSection(DataRefImpl Rel) const {
-  return section_iterator(getAnyRelocationSection(getRelocation(Rel)));
+  MachO::any_relocation_info RE;
+  if (getRelocation(Rel, RE))
+    return section_end();
+
+  return section_iterator(getAnyRelocationSection(RE));
 }
 
 std::error_code MachOObjectFile::getRelocationType(DataRefImpl Rel,
                                                    uint64_t &Res) const {
-  MachO::any_relocation_info RE = getRelocation(Rel);
+  MachO::any_relocation_info RE;
+  if (auto Err = getRelocation(Rel, RE))
+    return Err;
   Res = getAnyRelocationType(RE);
   return object_error::success;
 }
 
 std::error_code
 MachOObjectFile::getRelocationTypeName(DataRefImpl Rel,
                                        SmallVectorImpl<char> &Result) const {
   StringRef res;
MachOObjectFile::getRelocationTypeName(DataRefImpl Rel,
   }
   Result.append(res.begin(), res.end());
   return object_error::success;
 }
 
 std::error_code
 MachOObjectFile::getRelocationValueString(DataRefImpl Rel,
                                           SmallVectorImpl<char> &Result) const {
-  MachO::any_relocation_info RE = getRelocation(Rel);
+  MachO::any_relocation_info RE;
+  if (auto Err = getRelocation(Rel, RE))
+    return Err;
 
   unsigned Arch = this->getArch();
 
   std::string fmtbuf;
   raw_string_ostream fmt(fmtbuf);
   unsigned Type = this->getAnyRelocationType(RE);
   bool IsPCRel = this->getAnyRelocationPCRel(RE);
 
switch (Type) {
         printRelocationTargetName(this, RE, fmt);
         fmt << "@GOT";
         if (isPCRel) fmt << "PCREL";
         break;
       }
       case MachO::X86_64_RELOC_SUBTRACTOR: {
         DataRefImpl RelNext = Rel;
         moveRelocationNext(RelNext);
-        MachO::any_relocation_info RENext = getRelocation(RelNext);
+        MachO::any_relocation_info RENext;
+        if (auto Err = getRelocation(RelNext, RENext))
+          return Err;
 
         // X86_64_RELOC_SUBTRACTOR must be followed by a relocation of type
         // X86_64_RELOC_UNSIGNED.
         // NOTE: Scattered relocations don't exist on x86_64.
         unsigned RType = getAnyRelocationType(RENext);
         if (RType != MachO::X86_64_RELOC_UNSIGNED)
           report_fatal_error("Expected X86_64_RELOC_UNSIGNED after "
                              "X86_64_RELOC_SUBTRACTOR.");
// X86 and ARM share some relocation types in common.
              Arch == Triple::ppc) {
     // Generic relocation types...
     switch (Type) {
       case MachO::GENERIC_RELOC_PAIR: // prints no info
         return object_error::success;
       case MachO::GENERIC_RELOC_SECTDIFF: {
         DataRefImpl RelNext = Rel;
         moveRelocationNext(RelNext);
-        MachO::any_relocation_info RENext = getRelocation(RelNext);
+        MachO::any_relocation_info RENext;
+        if (auto Err = getRelocation(RelNext, RENext))
+          return Err;
 
         // X86 sect diff's must be followed by a relocation of type
         // GENERIC_RELOC_PAIR.
         unsigned RType = getAnyRelocationType(RENext);
 
         if (RType != MachO::GENERIC_RELOC_PAIR)
           report_fatal_error("Expected GENERIC_RELOC_PAIR after "
                              "GENERIC_RELOC_SECTDIFF.");
 
         printRelocationTargetName(this, RE, fmt);
         fmt << "-";
         printRelocationTargetName(this, RENext, fmt);
         break;
       }
     }
 
     if (Arch == Triple::x86 || Arch == Triple::ppc) {
       switch (Type) {
         case MachO::GENERIC_RELOC_LOCAL_SECTDIFF: {
           DataRefImpl RelNext = Rel;
           moveRelocationNext(RelNext);
-          MachO::any_relocation_info RENext = getRelocation(RelNext);
+          MachO::any_relocation_info RENext;
+          if (auto Err = getRelocation(RelNext, RENext))
+            return Err;
 
           // X86 sect diff's must be followed by a relocation of type
           // GENERIC_RELOC_PAIR.
           unsigned RType = getAnyRelocationType(RENext);
           if (RType != MachO::GENERIC_RELOC_PAIR)
             report_fatal_error("Expected GENERIC_RELOC_PAIR after "
                                "GENERIC_RELOC_LOCAL_SECTDIFF.");
 
if (Arch == Triple::x86 || Arch == Triple::ppc) {
           if (isUpper)
             fmt << ":upper16:(";
           else
             fmt << ":lower16:(";
           printRelocationTargetName(this, RE, fmt);
 
           DataRefImpl RelNext = Rel;
           moveRelocationNext(RelNext);
-          MachO::any_relocation_info RENext = getRelocation(RelNext);
+          MachO::any_relocation_info RENext;
+          if (auto Err = getRelocation(RelNext, RENext))
+            return Err;
 
           // ARM half relocs must be followed by a relocation of type
           // ARM_RELOC_PAIR.
           unsigned RType = getAnyRelocationType(RENext);
           if (RType != MachO::ARM_RELOC_PAIR)
             report_fatal_error("Expected ARM_RELOC_PAIR after "
                                "ARM_RELOC_HALF");
 
std::error_code MachOObjectFile::getLibraryShortNameByIndex(unsigned Index,
                                                          StringRef &Res) const {
   if (Index >= Libraries.size())
     return object_error::parse_failed;
 
   // If the cache of LibrariesShortNames is not built up do that first for
   // all the Libraries.
   if (LibrariesShortNames.size() == 0) {
     for (unsigned i = 0; i < Libraries.size(); i++) {
-      MachO::dylib_command D =
-        getStruct<MachO::dylib_command>(this, Libraries[i]);
+      MachO::dylib_command D;
+      if (auto Err = getStruct(this, Libraries[i], D))
+        return Err;
       if (D.dylib.name >= D.cmdsize)
         return object_error::parse_failed;
       const char *P = (const char *)(Libraries[i]) + D.dylib.name;
       StringRef Name = StringRef(P);
       if (D.dylib.name+Name.size() >= D.cmdsize)
         return object_error::parse_failed;
       StringRef Suffix;
       bool isFramework;
basic_symbol_iterator MachOObjectFile::symbol_begin_impl() const {
   return getSymbolByIndex(0);
 }
 
 basic_symbol_iterator MachOObjectFile::symbol_end_impl() const {
   DataRefImpl DRI;
   if (!SymtabLoadCmd)
     return basic_symbol_iterator(SymbolRef(DRI, this));
 
-  MachO::symtab_command Symtab = getSymtabLoadCommand();
+  MachO::symtab_command Symtab;
+  if (getSymtabLoadCommand(Symtab))
+    return basic_symbol_iterator(SymbolRef(DRI, this));
+
   unsigned SymbolTableEntrySize = is64Bit() ?
     sizeof(MachO::nlist_64) :
     sizeof(MachO::nlist);
   unsigned Offset = Symtab.symoff +
     Symtab.nsyms * SymbolTableEntrySize;
   DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset));
   return basic_symbol_iterator(SymbolRef(DRI, this));
 }
 
 basic_symbol_iterator MachOObjectFile::getSymbolByIndex(unsigned Index) const {
   DataRefImpl DRI;
   if (!SymtabLoadCmd)
     return basic_symbol_iterator(SymbolRef(DRI, this));
 
-  MachO::symtab_command Symtab = getSymtabLoadCommand();
+  MachO::symtab_command Symtab;
+  if (getSymtabLoadCommand(Symtab))
+    return basic_symbol_iterator(SymbolRef(DRI, this));
+
   if (Index >= Symtab.nsyms)
     report_fatal_error("Requested symbol index is out of range.");
   unsigned SymbolTableEntrySize =
     is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
   DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Symtab.symoff));
   DRI.p += Index * SymbolTableEntrySize;
   return basic_symbol_iterator(SymbolRef(DRI, this));
 }
section_iterator MachOObjectFile::section_end() const {
   return section_iterator(SectionRef(DRI, this));
 }
 
 uint8_t MachOObjectFile::getBytesInAddress() const {
   return is64Bit() ? 8 : 4;
 }
 
 StringRef MachOObjectFile::getFileFormatName() const {
-  unsigned CPUType = getCPUType(this);
+  unsigned CPUType;
+  if (getCPUType(this, CPUType))
+    return "Mach-O unknown";
   if (!is64Bit()) {
     switch (CPUType) {
     case llvm::MachO::CPU_TYPE_I386:
       return "Mach-O 32-bit i386";
     case llvm::MachO::CPU_TYPE_ARM:
       return "Mach-O arm";
     case llvm::MachO::CPU_TYPE_POWERPC:
       return "Mach-O 32-bit ppc";
return StringSwitch<bool>(ArchFlag)
       .Case("armv7s", true)
       .Case("arm64", true)
       .Case("ppc", true)
       .Case("ppc64", true)
       .Default(false);
 }
 
 unsigned MachOObjectFile::getArch() const {
-  return getArch(getCPUType(this));
+  unsigned CPUType;
+  if (getCPUType(this, CPUType))
+    return Triple::UnknownArch;
+  return getArch(CPUType);
 }
 
 Triple MachOObjectFile::getArch(const char **McpuDefault,
                                 Triple *ThumbTriple) const {
   Triple T;
   if (is64Bit()) {
     MachO::mach_header_64 H_64;
-    H_64 = getHeader64();
+    if (getHeader64(H_64))
+      return Triple();
     T = MachOObjectFile::getArch(H_64.cputype, H_64.cpusubtype, McpuDefault);
     *ThumbTriple = MachOObjectFile::getThumbArch(H_64.cputype, H_64.cpusubtype,
                                                  McpuDefault);
   } else {
     MachO::mach_header H;
-    H = getHeader();
+    if (getHeader(H))
+      return Triple();
     T = MachOObjectFile::getArch(H.cputype, H.cpusubtype, McpuDefault);
     *ThumbTriple = MachOObjectFile::getThumbArch(H.cputype, H.cpusubtype,
                                                  McpuDefault);
   }
   return T;
 }
 
 relocation_iterator MachOObjectFile::section_rel_begin(unsigned Index) const {
   DataRefImpl DRI;
   DRI.d.a = Index;
   return section_rel_begin(DRI);
 }
 
 relocation_iterator MachOObjectFile::section_rel_end(unsigned Index) const {
   DataRefImpl DRI;
   DRI.d.a = Index;
   return section_rel_end(DRI);
 }
 
 dice_iterator MachOObjectFile::begin_dices() const {
   DataRefImpl DRI;
   if (!DataInCodeLoadCmd)
     return dice_iterator(DiceRef(DRI, this));
 
-  MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
+  MachO::linkedit_data_command DicLC;
+  if (getDataInCodeLoadCommand(DicLC))
+    return dice_iterator(DiceRef(DRI, this));
+
   DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, DicLC.dataoff));
   return dice_iterator(DiceRef(DRI, this));
 }
 
 dice_iterator MachOObjectFile::end_dices() const {
   DataRefImpl DRI;
   if (!DataInCodeLoadCmd)
     return dice_iterator(DiceRef(DRI, this));
 
-  MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
+  MachO::linkedit_data_command DicLC;
+  if (getDataInCodeLoadCommand(DicLC))
+    return dice_iterator(DiceRef(DRI, this));
+
   unsigned Offset = DicLC.dataoff + DicLC.datasize;
   DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset));
   return dice_iterator(DiceRef(DRI, this));
 }
 
 ExportEntry::ExportEntry(ArrayRef<uint8_t> T) 
   : Trie(T), Malformed(false), Done(false) { }
 

 ArrayRef<char>
 MachOObjectFile::getSectionRawFinalSegmentName(DataRefImpl Sec) const {
   assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
   const section_base *Base =
     reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
   return makeArrayRef(Base->segname);
 }
 
-bool
-MachOObjectFile::isRelocationScattered(const MachO::any_relocation_info &RE)
-  const {
-  if (getCPUType(this) == MachO::CPU_TYPE_X86_64)
+bool MachOObjectFile::isRelocationScattered(
+    const MachO::any_relocation_info &RE) const {
+  unsigned CPUType;
+  if (getCPUType(this, CPUType))
+    return false;
+  if (CPUType == MachO::CPU_TYPE_X86_64)
     return false;
   return getPlainRelocationAddress(RE) & MachO::R_SCATTERED;
 }
 
 unsigned MachOObjectFile::getPlainRelocationSymbolNum(
     const MachO::any_relocation_info &RE) const {
   if (isLittleEndian())
     return RE.r_word1 & 0xffffff;
MachOObjectFile::getAnyRelocationSection(
   if (isRelocationScattered(RE) || getPlainRelocationExternal(RE))
     return *section_end();
   unsigned SecNum = getPlainRelocationSymbolNum(RE) - 1;
   DataRefImpl DRI;
   DRI.d.a = SecNum;
   return SectionRef(DRI, this);
 }
 
-MachOObjectFile::LoadCommandInfo
-MachOObjectFile::getFirstLoadCommandInfo() const {
-  MachOObjectFile::LoadCommandInfo Load;
-
+std::error_code
+MachOObjectFile::getFirstLoadCommandInfo(LoadCommandInfo &Load) const {
   unsigned HeaderSize = is64Bit() ? sizeof(MachO::mach_header_64) :
                                     sizeof(MachO::mach_header);
   Load.Ptr = getPtr(this, HeaderSize);
-  Load.C = getStruct<MachO::load_command>(this, Load.Ptr);
+  if (auto Err = getStruct(this, Load.Ptr, Load.C))
+    return Err;
+  // Load command with size < 8 bytes.
   if (Load.C.cmdsize < 8)
-    report_fatal_error("Load command with size < 8 bytes.");
-  return Load;
+    return object_error::parse_failed;
+  return std::error_code();
 }
 
-MachOObjectFile::LoadCommandInfo
-MachOObjectFile::getNextLoadCommandInfo(const LoadCommandInfo &L) const {
-  MachOObjectFile::LoadCommandInfo Next;
+std::error_code
+MachOObjectFile::getNextLoadCommandInfo(const LoadCommandInfo &L,
+                                        LoadCommandInfo &Next) const {
   Next.Ptr = L.Ptr + L.C.cmdsize;
-  Next.C = getStruct<MachO::load_command>(this, Next.Ptr);
+  if (auto Err = getStruct(this, Next.Ptr, Next.C))
+    return Err;
+  // Load command with size < 8 bytes.
   if (Next.C.cmdsize < 8)
-    report_fatal_error("Load command with size < 8 bytes.");
-  return Next;
+    return object_error::parse_failed;
+  return std::error_code();
 }
 
-MachO::section MachOObjectFile::getSection(DataRefImpl DRI) const {
+std::error_code MachOObjectFile::getSection(DataRefImpl DRI,
+                                            MachO::section &Section) const {
   assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
-  return getStruct<MachO::section>(this, Sections[DRI.d.a]);
+  return getStruct(this, Sections[DRI.d.a], Section);
 }
 
-MachO::section_64 MachOObjectFile::getSection64(DataRefImpl DRI) const {
+std::error_code
+MachOObjectFile::getSection64(DataRefImpl DRI,
+                              MachO::section_64 &Section) const {
   assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
-  return getStruct<MachO::section_64>(this, Sections[DRI.d.a]);
+  return getStruct(this, Sections[DRI.d.a], Section);
 }
 
-MachO::section MachOObjectFile::getSection(const LoadCommandInfo &L,
-                                           unsigned Index) const {
+std::error_code MachOObjectFile::getSection(const LoadCommandInfo &L,
+                                            unsigned Index,
+                                            MachO::section &Section) const {
   const char *Sec = getSectionPtr(this, L, Index);
-  return getStruct<MachO::section>(this, Sec);
+  return getStruct(this, Sec, Section);
 }
 
-MachO::section_64 MachOObjectFile::getSection64(const LoadCommandInfo &L,
-                                                unsigned Index) const {
+std::error_code
+MachOObjectFile::getSection64(const LoadCommandInfo &L, unsigned Index,
+                              MachO::section_64 &Section) const {
   const char *Sec = getSectionPtr(this, L, Index);
-  return getStruct<MachO::section_64>(this, Sec);
+  return getStruct(this, Sec, Section);
 }
 
-MachO::nlist
-MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI) const {
+std::error_code
+MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI,
+                                     MachO::nlist &Nlist) const {
   const char *P = reinterpret_cast<const char *>(DRI.p);
-  return getStruct<MachO::nlist>(this, P);
+  return getStruct(this, P, Nlist);
 }
 
-MachO::nlist_64
-MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI) const {
+std::error_code
+MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI,
+                                       MachO::nlist_64 &Nlist) const {
   const char *P = reinterpret_cast<const char *>(DRI.p);
-  return getStruct<MachO::nlist_64>(this, P);
+  return getStruct(this, P, Nlist);
 }
 
-MachO::linkedit_data_command
-MachOObjectFile::getLinkeditDataLoadCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::linkedit_data_command>(this, L.Ptr);
+std::error_code MachOObjectFile::getLinkeditDataLoadCommand(
+    const LoadCommandInfo &L, MachO::linkedit_data_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::segment_command
-MachOObjectFile::getSegmentLoadCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::segment_command>(this, L.Ptr);
+std::error_code
+MachOObjectFile::getSegmentLoadCommand(const LoadCommandInfo &L,
+                                       MachO::segment_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::segment_command_64
-MachOObjectFile::getSegment64LoadCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::segment_command_64>(this, L.Ptr);
+std::error_code
+MachOObjectFile::getSegment64LoadCommand(const LoadCommandInfo &L,
+                                         MachO::segment_command_64 &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::linker_option_command
-MachOObjectFile::getLinkerOptionLoadCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::linker_option_command>(this, L.Ptr);
+std::error_code MachOObjectFile::getLinkerOptionLoadCommand(
+    const LoadCommandInfo &L, MachO::linker_option_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::version_min_command
-MachOObjectFile::getVersionMinLoadCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::version_min_command>(this, L.Ptr);
+std::error_code MachOObjectFile::getVersionMinLoadCommand(
+    const LoadCommandInfo &L, MachO::version_min_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::dylib_command
-MachOObjectFile::getDylibIDLoadCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::dylib_command>(this, L.Ptr);
+std::error_code
+MachOObjectFile::getDylibIDLoadCommand(const LoadCommandInfo &L,
+                                       MachO::dylib_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::dyld_info_command
-MachOObjectFile::getDyldInfoLoadCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::dyld_info_command>(this, L.Ptr);
+std::error_code
+MachOObjectFile::getDyldInfoLoadCommand(const LoadCommandInfo &L,
+                                        MachO::dyld_info_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::dylinker_command
-MachOObjectFile::getDylinkerCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::dylinker_command>(this, L.Ptr);
+std::error_code
+MachOObjectFile::getDylinkerCommand(const LoadCommandInfo &L,
+                                    MachO::dylinker_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::uuid_command
-MachOObjectFile::getUuidCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::uuid_command>(this, L.Ptr);
+std::error_code
+MachOObjectFile::getUuidCommand(const LoadCommandInfo &L,
+                                MachO::uuid_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::rpath_command
-MachOObjectFile::getRpathCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::rpath_command>(this, L.Ptr);
+std::error_code
+MachOObjectFile::getRpathCommand(const LoadCommandInfo &L,
+                                 MachO::rpath_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::source_version_command
-MachOObjectFile::getSourceVersionCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::source_version_command>(this, L.Ptr);
+std::error_code MachOObjectFile::getSourceVersionCommand(
+    const LoadCommandInfo &L, MachO::source_version_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::entry_point_command
-MachOObjectFile::getEntryPointCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::entry_point_command>(this, L.Ptr);
+std::error_code
+MachOObjectFile::getEntryPointCommand(const LoadCommandInfo &L,
+                                      MachO::entry_point_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::encryption_info_command
-MachOObjectFile::getEncryptionInfoCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::encryption_info_command>(this, L.Ptr);
+std::error_code MachOObjectFile::getEncryptionInfoCommand(
+    const LoadCommandInfo &L, MachO::encryption_info_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::encryption_info_command_64
-MachOObjectFile::getEncryptionInfoCommand64(const LoadCommandInfo &L) const {
-  return getStruct<MachO::encryption_info_command_64>(this, L.Ptr);
+std::error_code MachOObjectFile::getEncryptionInfoCommand64(
+    const LoadCommandInfo &L, MachO::encryption_info_command_64 &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::sub_framework_command
-MachOObjectFile::getSubFrameworkCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::sub_framework_command>(this, L.Ptr);
+std::error_code MachOObjectFile::getSubFrameworkCommand(
+    const LoadCommandInfo &L, MachO::sub_framework_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::sub_umbrella_command
-MachOObjectFile::getSubUmbrellaCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::sub_umbrella_command>(this, L.Ptr);
+std::error_code
+MachOObjectFile::getSubUmbrellaCommand(const LoadCommandInfo &L,
+                                       MachO::sub_umbrella_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::sub_library_command
-MachOObjectFile::getSubLibraryCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::sub_library_command>(this, L.Ptr);
+std::error_code
+MachOObjectFile::getSubLibraryCommand(const LoadCommandInfo &L,
+                                      MachO::sub_library_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::sub_client_command
-MachOObjectFile::getSubClientCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::sub_client_command>(this, L.Ptr);
+std::error_code
+MachOObjectFile::getSubClientCommand(const LoadCommandInfo &L,
+                                     MachO::sub_client_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::routines_command
-MachOObjectFile::getRoutinesCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::routines_command>(this, L.Ptr);
+std::error_code
+MachOObjectFile::getRoutinesCommand(const LoadCommandInfo &L,
+                                    MachO::routines_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::routines_command_64
-MachOObjectFile::getRoutinesCommand64(const LoadCommandInfo &L) const {
-  return getStruct<MachO::routines_command_64>(this, L.Ptr);
+std::error_code
+MachOObjectFile::getRoutinesCommand64(const LoadCommandInfo &L,
+                                      MachO::routines_command_64 &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::thread_command
-MachOObjectFile::getThreadCommand(const LoadCommandInfo &L) const {
-  return getStruct<MachO::thread_command>(this, L.Ptr);
+std::error_code
+MachOObjectFile::getThreadCommand(const LoadCommandInfo &L,
+                                  MachO::thread_command &Cmd) const {
+  return getStruct(this, L.Ptr, Cmd);
 }
 
-MachO::any_relocation_info
-MachOObjectFile::getRelocation(DataRefImpl Rel) const {
+std::error_code
+MachOObjectFile::getRelocation(DataRefImpl Rel,
+                               MachO::any_relocation_info &RelInfo) const {
   DataRefImpl Sec;
   Sec.d.a = Rel.d.a;
   uint32_t Offset;
   if (is64Bit()) {
-    MachO::section_64 Sect = getSection64(Sec);
+    MachO::section_64 Sect;
+    if (auto Err = getSection64(Sec, Sect))
+      return Err;
     Offset = Sect.reloff;
   } else {
-    MachO::section Sect = getSection(Sec);
+    MachO::section Sect;
+    if (auto Err = getSection(Sec, Sect))
+      return Err;
     Offset = Sect.reloff;
   }
 
   auto P = reinterpret_cast<const MachO::any_relocation_info *>(
       getPtr(this, Offset)) + Rel.d.b;
-  return getStruct<MachO::any_relocation_info>(
-      this, reinterpret_cast<const char *>(P));
+  return getStruct(this, reinterpret_cast<const char *>(P), RelInfo);
 }
 
-MachO::data_in_code_entry
-MachOObjectFile::getDice(DataRefImpl Rel) const {
+std::error_code
+MachOObjectFile::getDice(DataRefImpl Rel,
+                         MachO::data_in_code_entry &Dice) const {
   const char *P = reinterpret_cast<const char *>(Rel.p);
-  return getStruct<MachO::data_in_code_entry>(this, P);
+  return getStruct(this, P, Dice);
 }
 
-MachO::mach_header MachOObjectFile::getHeader() const {
-  return getStruct<MachO::mach_header>(this, getPtr(this, 0));
+std::error_code MachOObjectFile::getHeader(MachO::mach_header &Header) const {
+  return getStruct(this, getPtr(this, 0), Header);
 }
 
-MachO::mach_header_64 MachOObjectFile::getHeader64() const {
-  return getStruct<MachO::mach_header_64>(this, getPtr(this, 0));
+std::error_code
+MachOObjectFile::getHeader64(MachO::mach_header_64 &Header) const {
+  return getStruct(this, getPtr(this, 0), Header);
 }
 
-uint32_t MachOObjectFile::getIndirectSymbolTableEntry(
-                                             const MachO::dysymtab_command &DLC,
-                                             unsigned Index) const {
+std::error_code MachOObjectFile::getIndirectSymbolTableEntry(
+    const MachO::dysymtab_command &DLC, unsigned Index, uint32_t &Res) const {
   uint64_t Offset = DLC.indirectsymoff + Index * sizeof(uint32_t);
-  return getStruct<uint32_t>(this, getPtr(this, Offset));
+  return getStruct(this, getPtr(this, Offset), Res);
 }
 
-MachO::data_in_code_entry
-MachOObjectFile::getDataInCodeTableEntry(uint32_t DataOffset,
-                                         unsigned Index) const {
+std::error_code MachOObjectFile::getDataInCodeTableEntry(
+    uint32_t DataOffset, unsigned Index,
+    MachO::data_in_code_entry &Dice) const {
   uint64_t Offset = DataOffset + Index * sizeof(MachO::data_in_code_entry);
-  return getStruct<MachO::data_in_code_entry>(this, getPtr(this, Offset));
+  return getStruct(this, getPtr(this, Offset), Dice);
 }
 
-MachO::symtab_command MachOObjectFile::getSymtabLoadCommand() const {
+std::error_code
+MachOObjectFile::getSymtabLoadCommand(MachO::symtab_command &Cmd) const {
   if (SymtabLoadCmd)
-    return getStruct<MachO::symtab_command>(this, SymtabLoadCmd);
+    return getStruct(this, SymtabLoadCmd, Cmd);
 
   // If there is no SymtabLoadCmd return a load command with zero'ed fields.
-  MachO::symtab_command Cmd;
   Cmd.cmd = MachO::LC_SYMTAB;
   Cmd.cmdsize = sizeof(MachO::symtab_command);
   Cmd.symoff = 0;
   Cmd.nsyms = 0;
   Cmd.stroff = 0;
   Cmd.strsize = 0;
-  return Cmd;
+  return std::error_code();
 }
 
-MachO::dysymtab_command MachOObjectFile::getDysymtabLoadCommand() const {
+std::error_code
+MachOObjectFile::getDysymtabLoadCommand(MachO::dysymtab_command &Cmd) const {
   if (DysymtabLoadCmd)
-    return getStruct<MachO::dysymtab_command>(this, DysymtabLoadCmd);
+    return getStruct(this, DysymtabLoadCmd, Cmd);
 
   // If there is no DysymtabLoadCmd return a load command with zero'ed fields.
-  MachO::dysymtab_command Cmd;
   Cmd.cmd = MachO::LC_DYSYMTAB;
   Cmd.cmdsize = sizeof(MachO::dysymtab_command);
   Cmd.ilocalsym = 0;
   Cmd.nlocalsym = 0;
   Cmd.iextdefsym = 0;
   Cmd.nextdefsym = 0;
   Cmd.iundefsym = 0;
   Cmd.nundefsym = 0;
   Cmd.tocoff = 0;
   Cmd.ntoc = 0;
   Cmd.modtaboff = 0;
   Cmd.nmodtab = 0;
   Cmd.extrefsymoff = 0;
   Cmd.nextrefsyms = 0;
   Cmd.indirectsymoff = 0;
   Cmd.nindirectsyms = 0;
   Cmd.extreloff = 0;
   Cmd.nextrel = 0;
   Cmd.locreloff = 0;
   Cmd.nlocrel = 0;
-  return Cmd;
+  return std::error_code();
 }
 
-MachO::linkedit_data_command
-MachOObjectFile::getDataInCodeLoadCommand() const {
+std::error_code
+MachOObjectFile::getDataInCodeLoadCommand(MachO::linkedit_data_command &Cmd) const {
   if (DataInCodeLoadCmd)
-    return getStruct<MachO::linkedit_data_command>(this, DataInCodeLoadCmd);
+    return getStruct(this, DataInCodeLoadCmd, Cmd);
 
   // If there is no DataInCodeLoadCmd return a load command with zero'ed fields.
-  MachO::linkedit_data_command Cmd;
   Cmd.cmd = MachO::LC_DATA_IN_CODE;
   Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
   Cmd.dataoff = 0;
   Cmd.datasize = 0;
-  return Cmd;
+  return std::error_code();
 }
 
-MachO::linkedit_data_command
-MachOObjectFile::getLinkOptHintsLoadCommand() const {
+std::error_code
+MachOObjectFile::getLinkOptHintsLoadCommand(MachO::linkedit_data_command &Cmd) const {
   if (LinkOptHintsLoadCmd)
-    return getStruct<MachO::linkedit_data_command>(this, LinkOptHintsLoadCmd);
+    return getStruct(this, LinkOptHintsLoadCmd, Cmd);
 
   // If there is no LinkOptHintsLoadCmd return a load command with zero'ed
   // fields.
-  MachO::linkedit_data_command Cmd;
   Cmd.cmd = MachO::LC_LINKER_OPTIMIZATION_HINT;
   Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
   Cmd.dataoff = 0;
   Cmd.datasize = 0;
-  return Cmd;
+  return std::error_code();
 }
 
 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoRebaseOpcodes() const {
-  if (!DyldInfoLoadCmd) 
+  if (!DyldInfoLoadCmd)
     return ArrayRef<uint8_t>();
 
-  MachO::dyld_info_command DyldInfo 
-                   = getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd);
+  MachO::dyld_info_command DyldInfo;
+  if (getStruct(this, DyldInfoLoadCmd, DyldInfo))
+    return ArrayRef<uint8_t>();
   const uint8_t *Ptr = reinterpret_cast<const uint8_t*>(
                                              getPtr(this, DyldInfo.rebase_off));
   return ArrayRef<uint8_t>(Ptr, DyldInfo.rebase_size);
 }
 
 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoBindOpcodes() const {
-  if (!DyldInfoLoadCmd) 
+  if (!DyldInfoLoadCmd)
     return ArrayRef<uint8_t>();
 
-  MachO::dyld_info_command DyldInfo 
-                   = getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd);
+  MachO::dyld_info_command DyldInfo;
+  if (getStruct(this, DyldInfoLoadCmd, DyldInfo))
+    return ArrayRef<uint8_t>();
   const uint8_t *Ptr = reinterpret_cast<const uint8_t*>(
                                                getPtr(this, DyldInfo.bind_off));
   return ArrayRef<uint8_t>(Ptr, DyldInfo.bind_size);
 }
 
 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoWeakBindOpcodes() const {
-  if (!DyldInfoLoadCmd) 
+  if (!DyldInfoLoadCmd)
     return ArrayRef<uint8_t>();
 
-  MachO::dyld_info_command DyldInfo 
-                   = getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd);
+  MachO::dyld_info_command DyldInfo;
+  if (getStruct(this, DyldInfoLoadCmd, DyldInfo))
+    return ArrayRef<uint8_t>();
   const uint8_t *Ptr = reinterpret_cast<const uint8_t*>(
                                           getPtr(this, DyldInfo.weak_bind_off));
   return ArrayRef<uint8_t>(Ptr, DyldInfo.weak_bind_size);
 }
 
 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoLazyBindOpcodes() const {
-  if (!DyldInfoLoadCmd) 
+  if (!DyldInfoLoadCmd)
     return ArrayRef<uint8_t>();
 
-  MachO::dyld_info_command DyldInfo 
-                   = getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd);
+  MachO::dyld_info_command DyldInfo;
+  if (getStruct(this, DyldInfoLoadCmd, DyldInfo))
+    return ArrayRef<uint8_t>();
   const uint8_t *Ptr = reinterpret_cast<const uint8_t*>(
                                           getPtr(this, DyldInfo.lazy_bind_off));
   return ArrayRef<uint8_t>(Ptr, DyldInfo.lazy_bind_size);
 }
 
 ArrayRef<uint8_t> MachOObjectFile::getDyldInfoExportsTrie() const {
-  if (!DyldInfoLoadCmd) 
+  if (!DyldInfoLoadCmd)
     return ArrayRef<uint8_t>();
 
-  MachO::dyld_info_command DyldInfo 
-                   = getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd);
+  MachO::dyld_info_command DyldInfo;
+  if (getStruct(this, DyldInfoLoadCmd, DyldInfo))
+    return ArrayRef<uint8_t>();
   const uint8_t *Ptr = reinterpret_cast<const uint8_t*>(
                                              getPtr(this, DyldInfo.export_off));
   return ArrayRef<uint8_t>(Ptr, DyldInfo.export_size);
 }
 
 ArrayRef<uint8_t> MachOObjectFile::getUuid() const {
   if (!UuidLoadCmd)
     return ArrayRef<uint8_t>();
   // Returning a pointer is fine as uuid doesn't need endian swapping.
   const char *Ptr = UuidLoadCmd + offsetof(MachO::uuid_command, uuid);
   return ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(Ptr), 16);
 }
 
-StringRef MachOObjectFile::getStringTableData() const {
-  MachO::symtab_command S = getSymtabLoadCommand();
-  return getData().substr(S.stroff, S.strsize);
+std::error_code MachOObjectFile::getStringTableData(StringRef &Res) const {
+  MachO::symtab_command S;
+  if (auto Err = getSymtabLoadCommand(S))
+    return Err;
+  Res = getData().substr(S.stroff, S.strsize);
+  return std::error_code();
 }
 
 bool MachOObjectFile::is64Bit() const {
   return getType() == getMachOType(false, true) ||
     getType() == getMachOType(true, true);
 }
 
 void MachOObjectFile::ReadULEB128s(uint64_t Index,
                                    SmallVectorImpl<uint64_t> &Out) const {
   DataExtractor extractor(ObjectFile::getData(), true, 0);
 
   uint32_t offset = Index;
   uint64_t data = 0;
   while (uint64_t delta = extractor.getULEB128(&offset)) {
     data += delta;
     Out.push_back(data);
   }
 }
 
 bool MachOObjectFile::isRelocatableObject() const {
-  return getHeader().filetype == MachO::MH_OBJECT;
+  MachO::mach_header Header;
+  if (getHeader(Header))
+    return false;
+  return Header.filetype == MachO::MH_OBJECT;
 }
 
 ErrorOr<std::unique_ptr<MachOObjectFile>>
 ObjectFile::createMachOObjectFile(MemoryBufferRef Buffer) {
   StringRef Magic = Buffer.getBuffer().slice(0, 4);
   std::error_code EC;
   std::unique_ptr<MachOObjectFile> Ret;
   if (Magic == "\xFE\xED\xFA\xCE")