[MachO] Add UnknownValueErrors and ability to ignore them.

[beanz]

Summary

This patch is a first step toward using the llvm::Error mechanism to surface non-fatal errors in object file handling. This patch adds a new error for unrecognized load command IDs, as an UnknownValueError.

It also adds the ability to ignore UnknownValueErrors since an object file with unknown values may still be structurally valid. This is particularly important for tools that need to operate correctly on binary files produced with newer compilers than the tool itself came from. For example, running an old LLDB on a binary compiled with a newer Clang would need to be able to ignore unknown load commands because we might have added new commands.

We will want to take this one step further by surfacing the object and errors through an "ErrorAnd" construct and allowing the recipient to determine how to handle each error. Since this patch is sufficiently large as-is, and feeding that through all the libObject common APIs is also a large change I'd like to do that in a separate patch.

Doing the larger cleanup will remove the "IgnoreValueErrors" parameter from the common APIs, but will require touching ELF and COFF as well as MachO.

[enderby]

lib/Object/MachOObjectFile.cpp

1465–1466

Seems like this bit of added logic will cause the loop over load commands to continue past all errors (even if the errors were not value errors) if IgnoreValueErrs is set and will not stop on the first error. If that what you intended? If so I'm not sure this code was written to be robust enough to handle this and not crash. And I doubt there are single file cases with multiple errors that are tested. Maybe you only wanted multiple value errors and not all multiple types of errors?

[beanz]

Kevin pointed out in his feedback some problems with the aproach I was taking in the Mach-O code. As I thought through it more, my aproach was really not the right way to go.

This patch simplifies the Mach-O code by keeping the malformedErrors and unknownValue errors separately, then joining them after the constructor exits. This approach minimizes the invasiveness of building error lists, and eliminates the unintended behavioral differences that my initial patch introduced.

Thanks for the feedback Kevin!

[enderby]

Do you plan to add any test cases at this time where IgnoreValueErrs is true? Or is that to be left to be done later in a future step?

[beanz]

There is actually already a test case that tests IgnoreValueErrs=true. That is covered in the (poorly named) obj2yaml test bogus_load_command.yaml.

include/llvm/Object/Binary.h

return !(TypeID == ID_ELF32B || TypeID == ID_ELF64B ||
              TypeID == ID_MachO32B || TypeID == ID_MachO64B);
   }
 };
 
 /// @brief Create a Binary from Source, autodetecting the file type.
 ///
 /// @param Source The data to create the Binary from.
 Expected<std::unique_ptr<Binary>> createBinary(MemoryBufferRef Source,
-                                               LLVMContext *Context = nullptr);
+                                               LLVMContext *Context = nullptr,
+                                               bool IgnoreValueErrs = false);
 
 template <typename T> class OwningBinary {
   std::unique_ptr<T> Bin;
   std::unique_ptr<MemoryBuffer> Buf;
 
 public:
   OwningBinary();
   OwningBinary(std::unique_ptr<T> Bin, std::unique_ptr<MemoryBuffer> Buf);

 template <typename T> T* OwningBinary<T>::getBinary() {
   return Bin.get();
 }
 
 template <typename T> const T* OwningBinary<T>::getBinary() const {
   return Bin.get();
 }
 
-Expected<OwningBinary<Binary>> createBinary(StringRef Path);
+Expected<OwningBinary<Binary>> createBinary(StringRef Path,
+                                            bool IgnoreValueErrs = false);
 }
 }
 
 #endif

include/llvm/Object/Error.h

public:
   GenericBinaryError(Twine Msg);
   GenericBinaryError(Twine Msg, object_error ECOverride);
   const std::string &getMessage() const { return Msg; }
   void log(raw_ostream &OS) const override;
 private:
   std::string Msg;
 };
 
+/// Unknown value error.
+///
+/// This type is for unrecognized values in otherwise correct binaries. This is
+/// used in the Mach-o parser for unrecognized load command ids, but could be
+/// expanded to encompass other unrecognized values that do not impact the
+/// ability to parse an object file.
+class UnknownValueError : public ErrorInfo<UnknownValueError, BinaryError> {
+public:
+  static char ID;
+  UnknownValueError(Twine Msg);
+  UnknownValueError(Twine Msg, object_error ECOverride);
+  const std::string &getMessage() const { return Msg; }
+  void log(raw_ostream &OS) const override;
+private:
+  std::string Msg;
+};
+
+Error filterUnknownValueErrors(Error Err);
+
 /// isNotObjectErrorInvalidFileType() is used when looping through the children
 /// of an archive after calling getAsBinary() on the child and it returns an
 /// llvm::Error.  In the cases we want to loop through the children and ignore the
 /// non-objects in the archive this is used to test the error to see if an
 /// error() function needs to called on the llvm::Error.
 Error isNotObjectErrorInvalidFileType(llvm::Error Err);
 
 } // end namespace object.

include/llvm/Object/MachO.h

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;
 
   static Expected<std::unique_ptr<MachOObjectFile>>
   create(MemoryBufferRef Object, bool IsLittleEndian, bool Is64Bits,
-         uint32_t UniversalCputype = 0, uint32_t UniversalIndex = 0);
+         uint32_t UniversalCputype = 0, uint32_t UniversalIndex = 0,
+         bool IgnoreValueErrs = false);
 
   void moveSymbolNext(DataRefImpl &Symb) const override;
 
   uint64_t getNValue(DataRefImpl Sym) const;
   Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
 
   // MachO specific.
   Error checkSymbolTable() const;
public:
   getVersionMinUpdate(MachO::version_min_command &C, bool SDK) {
     uint32_t VersionOrSDK = (SDK) ? C.sdk : C.version;
     return VersionOrSDK & 0xff;
   }
 
 private:
 
   MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian, bool Is64Bits,
-                  Error &Err, uint32_t UniversalCputype = 0,
-                  uint32_t UniversalIndex = 0);
+                  Error &Err, Error &ValueErr, uint32_t UniversalCputype = 0,
+                  uint32_t UniversalIndex = 0, bool IgnoreValueErrs = false);
 
   uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
 
   union {
     MachO::mach_header_64 Header64;
     MachO::mach_header Header;
   };
   typedef SmallVector<const char*, 1> SectionList;

include/llvm/Object/ObjectFile.h

public:
   }
 
   /// True if this is a relocatable object (.o/.obj).
   virtual bool isRelocatableObject() const = 0;
 
   /// @returns Pointer to ObjectFile subclass to handle this type of object.
   /// @param ObjectPath The path to the object file. ObjectPath.isObject must
   ///        return true.
+  /// @param IgnoreValueErrors Bool to allow creating object files that are not
+  ///        semantically valid, but are structurally correct.
   /// @brief Create ObjectFile from path.
   static Expected<OwningBinary<ObjectFile>>
-  createObjectFile(StringRef ObjectPath);
+  createObjectFile(StringRef ObjectPath, bool IgnoreValueErrs = false);
 
   static Expected<std::unique_ptr<ObjectFile>>
-  createObjectFile(MemoryBufferRef Object, sys::fs::file_magic Type);
+  createObjectFile(MemoryBufferRef Object, sys::fs::file_magic Type,
+                   bool IgnoreValueErrs = false);
   static Expected<std::unique_ptr<ObjectFile>>
-  createObjectFile(MemoryBufferRef Object) {
-    return createObjectFile(Object, sys::fs::file_magic::unknown);
+  createObjectFile(MemoryBufferRef Object, bool IgnoreValueErrs = false) {
+    return createObjectFile(Object, sys::fs::file_magic::unknown,
+                            IgnoreValueErrs);
   }
 
-
   static inline bool classof(const Binary *v) {
     return v->isObject();
   }
 
   static ErrorOr<std::unique_ptr<COFFObjectFile>>
   createCOFFObjectFile(MemoryBufferRef Object);
 
   static ErrorOr<std::unique_ptr<ObjectFile>>
   createELFObjectFile(MemoryBufferRef Object);
 
   static Expected<std::unique_ptr<MachOObjectFile>>
-  createMachOObjectFile(MemoryBufferRef Object,
+  createMachOObjectFile(MemoryBufferRef Object, bool IgnoreValueErrs = false,
                         uint32_t UniversalCputype = 0,
                         uint32_t UniversalIndex = 0);
-
 };
 
 // Inline function definitions.
 inline SymbolRef::SymbolRef(DataRefImpl SymbolP, const ObjectFile *Owner)
     : BasicSymbolRef(SymbolP, Owner) {}
 
 inline Expected<StringRef> SymbolRef::getName() const {
   return getObject()->getSymbolName(getRawDataRefImpl());

include/llvm/Object/SymbolicFile.h

public:
   typedef iterator_range<basic_symbol_iterator> basic_symbol_iterator_range;
   basic_symbol_iterator_range symbols() const {
     return basic_symbol_iterator_range(symbol_begin(), symbol_end());
   }
 
   // construction aux.
   static Expected<std::unique_ptr<SymbolicFile>>
   createSymbolicFile(MemoryBufferRef Object, sys::fs::file_magic Type,
-                     LLVMContext *Context);
+                     LLVMContext *Context, bool IgnoreValueErrs = false);
 
   static Expected<std::unique_ptr<SymbolicFile>>
-  createSymbolicFile(MemoryBufferRef Object) {
-    return createSymbolicFile(Object, sys::fs::file_magic::unknown, nullptr);
+  createSymbolicFile(MemoryBufferRef Object, bool IgnoreValueErrs = false) {
+    return createSymbolicFile(Object, sys::fs::file_magic::unknown, nullptr,
+                              IgnoreValueErrs);
   }
-  static Expected<OwningBinary<SymbolicFile>>
-  createSymbolicFile(StringRef ObjectPath);
 
   static inline bool classof(const Binary *v) {
     return v->isSymbolic();
   }
 };
 
 inline BasicSymbolRef::BasicSymbolRef(DataRefImpl SymbolP,
                                       const SymbolicFile *Owner)

lib/Object/Binary.cpp

 
 StringRef Binary::getData() const { return Data.getBuffer(); }
 
 StringRef Binary::getFileName() const { return Data.getBufferIdentifier(); }
 
 MemoryBufferRef Binary::getMemoryBufferRef() const { return Data; }
 
 Expected<std::unique_ptr<Binary>> object::createBinary(MemoryBufferRef Buffer,
-                                                      LLVMContext *Context) {
+                                                      LLVMContext *Context,
+                                                      bool IgnoreValueErrs) {
   sys::fs::file_magic Type = sys::fs::identify_magic(Buffer.getBuffer());
 
   switch (Type) {
     case sys::fs::file_magic::archive:
       return Archive::create(Buffer);
     case sys::fs::file_magic::elf:
     case sys::fs::file_magic::elf_relocatable:
     case sys::fs::file_magic::elf_executable:
switch (Type) {
     case sys::fs::file_magic::macho_bundle:
     case sys::fs::file_magic::macho_dynamically_linked_shared_lib_stub:
     case sys::fs::file_magic::macho_dsym_companion:
     case sys::fs::file_magic::macho_kext_bundle:
     case sys::fs::file_magic::coff_object:
     case sys::fs::file_magic::coff_import_library:
     case sys::fs::file_magic::pecoff_executable:
     case sys::fs::file_magic::bitcode:
-      return ObjectFile::createSymbolicFile(Buffer, Type, Context);
+      return ObjectFile::createSymbolicFile(Buffer, Type, Context, IgnoreValueErrs);
     case sys::fs::file_magic::macho_universal_binary:
       return MachOUniversalBinary::create(Buffer);
     case sys::fs::file_magic::unknown:
     case sys::fs::file_magic::coff_cl_gl_object:
     case sys::fs::file_magic::windows_resource:
       // Unrecognized object file format.
       return errorCodeToError(object_error::invalid_file_type);
   }
   llvm_unreachable("Unexpected Binary File Type");
 }
 
-Expected<OwningBinary<Binary>> object::createBinary(StringRef Path) {
+Expected<OwningBinary<Binary>> object::createBinary(StringRef Path,
+                                                    bool IgnoreValueErrs) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(Path);
   if (std::error_code EC = FileOrErr.getError())
     return errorCodeToError(EC);
   std::unique_ptr<MemoryBuffer> &Buffer = FileOrErr.get();
 
   Expected<std::unique_ptr<Binary>> BinOrErr =
-      createBinary(Buffer->getMemBufferRef());
+      createBinary(Buffer->getMemBufferRef(), nullptr, IgnoreValueErrs);
   if (!BinOrErr)
     return BinOrErr.takeError();
   std::unique_ptr<Binary> &Bin = BinOrErr.get();
 
   return OwningBinary<Binary>(std::move(Bin), std::move(Buffer));
 }

lib/Object/Error.cpp

case object_error::invalid_symbol_index:
     return "Invalid symbol index";
   }
   llvm_unreachable("An enumerator of object_error does not have a message "
                    "defined.");
 }
 
 char BinaryError::ID = 0;
 char GenericBinaryError::ID = 0;
+char UnknownValueError::ID = 0;
 
 GenericBinaryError::GenericBinaryError(Twine Msg) : Msg(Msg.str()) {}
 
 GenericBinaryError::GenericBinaryError(Twine Msg, object_error ECOverride)
     : Msg(Msg.str()) {
   setErrorCode(make_error_code(ECOverride));
 }
 
 void GenericBinaryError::log(raw_ostream &OS) const {
   OS << Msg;
 }
 
+UnknownValueError::UnknownValueError(Twine Msg) : Msg(Msg.str()) {}
+
+UnknownValueError::UnknownValueError(Twine Msg, object_error ECOverride)
+    : Msg(Msg.str()) {
+  setErrorCode(make_error_code(ECOverride));
+}
+
+void UnknownValueError::log(raw_ostream &OS) const {
+  OS << Msg;
+}
+
+Error object::filterUnknownValueErrors(Error Err) {
+  handleAllErrors(std::move(Err), [&](std::unique_ptr<UnknownValueError> E) {
+      // Ignore unknown value errors
+      (void)!E;
+    });
+  return Err;
+}
+
 static ManagedStatic<_object_error_category> error_category;
 
 const std::error_category &object::object_category() {
   return *error_category;
 }
 
 llvm::Error llvm::object::isNotObjectErrorInvalidFileType(llvm::Error Err) {
   if (auto Err2 =

lib/Object/MachOObjectFile.cpp

 
 static Error
 malformedError(Twine Msg) {
   std::string StringMsg = "truncated or malformed object (" + Msg.str() + ")";
   return make_error<GenericBinaryError>(std::move(StringMsg),
                                         object_error::parse_failed);
 }
 
+static Error
+unknownValueError(Twine Msg) {
+  std::string StringMsg = "unknown value found in object (" + Msg.str() + ")";
+  return make_error<UnknownValueError>(std::move(StringMsg),
+                                        object_error::parse_failed);
+}
+
 // FIXME: Replace all uses of this function with getStructOrErr.
 template <typename T>
 static T getStruct(const MachOObjectFile *O, const char *P) {
   // 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.");
 
   T Cmd;
if (cmd == MachO::LC_SYMSEG ||
       cmd == MachO::LC_PREBIND_CKSUM)
     return true;
   return false;
 }
 
 Expected<std::unique_ptr<MachOObjectFile>>
 MachOObjectFile::create(MemoryBufferRef Object, bool IsLittleEndian,
                         bool Is64Bits, uint32_t UniversalCputype,
-                        uint32_t UniversalIndex) {
+                        uint32_t UniversalIndex, bool IgnoreValueErrs) {
   Error Err = Error::success();
+  Error ValueErr = Error::success();
   std::unique_ptr<MachOObjectFile> Obj(
-      new MachOObjectFile(std::move(Object), IsLittleEndian,
-                          Is64Bits, Err, UniversalCputype,
-                          UniversalIndex));
+      new MachOObjectFile(std::move(Object), IsLittleEndian, Is64Bits, Err, ValueErr,
+                          UniversalCputype, UniversalIndex, IgnoreValueErrs));
+
+  if (ValueErr) {
+    if (IgnoreValueErrs)
+      handleAllErrors(std::move(ValueErr),
+                      [&](std::unique_ptr<UnknownValueError> E) {});
+    else
+      Err = joinErrors(std::move(Err), std::move(ValueErr));
+  }
   if (Err)
     return std::move(Err);
   return std::move(Obj);
 }
 
 MachOObjectFile::MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian,
-                                 bool Is64bits, Error &Err,
+                                 bool Is64bits, Error &Err, Error &ValueErr,
                                  uint32_t UniversalCputype,
-                                 uint32_t UniversalIndex)
+                                 uint32_t UniversalIndex,
+                                 bool IgnoreValueErrs)
     : ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object),
       SymtabLoadCmd(nullptr), DysymtabLoadCmd(nullptr),
       DataInCodeLoadCmd(nullptr), LinkOptHintsLoadCmd(nullptr),
       DyldInfoLoadCmd(nullptr), UuidLoadCmd(nullptr),
       HasPageZeroSegment(false) {
   ErrorAsOutParameter ErrAsOutParam(&Err);
+  ErrorAsOutParameter ValueErrAsOutParam(&ValueErr);
+  ValueErr = Error::success();
   uint64_t SizeOfHeaders;
   uint32_t cputype;
   if (is64Bit()) {
     parseHeader(this, Header64, Err);
     SizeOfHeaders = sizeof(MachO::mach_header_64);
     cputype = Header64.cputype;
   } else {
     parseHeader(this, Header, Err);
// Note: LC_TWOLEVEL_HINTS is really obsolete and is not supported.
        if ((Err = checkTwoLevelHintsCommand(this, Load, I,
                                             &TwoLevelHintsLoadCmd, Elements)))
          return;
     } else if (isLoadCommandObsolete(Load.C.cmd)) {
       Err = malformedError("load command " + Twine(I) + " for cmd value of: " +
                            Twine(Load.C.cmd) + " is obsolete and not "
                            "supported");
       return;
+    } else {
+      ValueErr = joinErrors(std::move(ValueErr),
+                            unknownValueError("unknown load command " +
+                                              Twine(I) + " for cmd value of: " +
+                                              Twine(Load.C.cmd)));
+      if (!IgnoreValueErrs)
+        return;
     }
-    // TODO: generate a error for unknown load commands by default.  But still
-    // need work out an approach to allow or not allow unknown values like this
-    // as an option for some uses like lldb.
+
     if (I < LoadCommandCount - 1) {
       if (auto LoadOrErr = getNextLoadCommandInfo(this, I, Load))
         Load = *LoadOrErr;
       else {
         Err = LoadOrErr.takeError();
         return;
       }
     }
   }
   if (!SymtabLoadCmd) {
     if (DysymtabLoadCmd) {
       Err = malformedError("contains LC_DYSYMTAB load command without a "
                            "LC_SYMTAB load command");
       return;
     }
   } else if (DysymtabLoadCmd) {
     MachO::symtab_command Symtab =
       getStruct<MachO::symtab_command>(this, SymtabLoadCmd);
while (uint64_t delta = extractor.getULEB128(&offset)) {
     Out.push_back(data);
   }
 }
 
 bool MachOObjectFile::isRelocatableObject() const {
   return getHeader().filetype == MachO::MH_OBJECT;
 }
 
-Expected<std::unique_ptr<MachOObjectFile>>
-ObjectFile::createMachOObjectFile(MemoryBufferRef Buffer,
-                                  uint32_t UniversalCputype,
-                                  uint32_t UniversalIndex) {
+Expected<std::unique_ptr<MachOObjectFile>> ObjectFile::createMachOObjectFile(
+    MemoryBufferRef Buffer, bool IgnoreValueErrs, uint32_t UniversalCputype,
   StringRef Magic = Buffer.getBuffer().slice(0, 4);
   if (Magic == "\xFE\xED\xFA\xCE")
-    return MachOObjectFile::create(Buffer, false, false,
-                                   UniversalCputype, UniversalIndex);
+    return MachOObjectFile::create(Buffer, false, false, UniversalCputype,
+                                   UniversalIndex, IgnoreValueErrs);
   if (Magic == "\xCE\xFA\xED\xFE")
-    return MachOObjectFile::create(Buffer, true, false,
-                                   UniversalCputype, UniversalIndex);
+    return MachOObjectFile::create(Buffer, true, false, UniversalCputype,
+                                   UniversalIndex, IgnoreValueErrs);
   if (Magic == "\xFE\xED\xFA\xCF")
-    return MachOObjectFile::create(Buffer, false, true,
-                                   UniversalCputype, UniversalIndex);
+    return MachOObjectFile::create(Buffer, false, true, UniversalCputype,
+                                   UniversalIndex, IgnoreValueErrs);
   if (Magic == "\xCF\xFA\xED\xFE")
-    return MachOObjectFile::create(Buffer, true, true,
-                                   UniversalCputype, UniversalIndex);
+    return MachOObjectFile::create(Buffer, true, true, UniversalCputype,
+                                   UniversalIndex, IgnoreValueErrs);
   return make_error<GenericBinaryError>("Unrecognized MachO magic number",
                                         object_error::invalid_file_type);
 }

lib/Object/MachOUniversal.cpp

if (Parent->getMagic() == MachO::FAT_MAGIC) {
     ObjectData = ParentData.substr(Header.offset, Header.size);
     cputype = Header.cputype;
   } else { // Parent->getMagic() == MachO::FAT_MAGIC_64
     ObjectData = ParentData.substr(Header64.offset, Header64.size);
     cputype = Header64.cputype;
   }
   StringRef ObjectName = Parent->getFileName();
   MemoryBufferRef ObjBuffer(ObjectData, ObjectName);
-  return ObjectFile::createMachOObjectFile(ObjBuffer, cputype, Index);
+  return ObjectFile::createMachOObjectFile(ObjBuffer, false, cputype, Index);
 }
 
 Expected<std::unique_ptr<Archive>>
 MachOUniversalBinary::ObjectForArch::getAsArchive() const {
   if (!Parent)
     report_fatal_error("MachOUniversalBinary::ObjectForArch::getAsArchive() "
                        "called when Parent is a nullptr");
 

lib/Object/ObjectFile.cpp

bool ObjectFile::isSectionBitcode(DataRefImpl Sec) const {
   return false;
 }
 
 section_iterator ObjectFile::getRelocatedSection(DataRefImpl Sec) const {
   return section_iterator(SectionRef(Sec, this));
 }
 
 Expected<std::unique_ptr<ObjectFile>>
-ObjectFile::createObjectFile(MemoryBufferRef Object, sys::fs::file_magic Type) {
+ObjectFile::createObjectFile(MemoryBufferRef Object, sys::fs::file_magic Type,
+                             bool IgnoreValueErrs) {
   StringRef Data = Object.getBuffer();
   if (Type == sys::fs::file_magic::unknown)
     Type = sys::fs::identify_magic(Data);
 
   switch (Type) {
   case sys::fs::file_magic::unknown:
   case sys::fs::file_magic::bitcode:
   case sys::fs::file_magic::coff_cl_gl_object:
ObjectFile::createObjectFile(MemoryBufferRef Object, sys::fs::file_magic Type,
   case sys::fs::file_magic::macho_core:
   case sys::fs::file_magic::macho_preload_executable:
   case sys::fs::file_magic::macho_dynamically_linked_shared_lib:
   case sys::fs::file_magic::macho_dynamic_linker:
   case sys::fs::file_magic::macho_bundle:
   case sys::fs::file_magic::macho_dynamically_linked_shared_lib_stub:
   case sys::fs::file_magic::macho_dsym_companion:
   case sys::fs::file_magic::macho_kext_bundle:
-    return createMachOObjectFile(Object);
+    return createMachOObjectFile(Object, IgnoreValueErrs);
   case sys::fs::file_magic::coff_object:
   case sys::fs::file_magic::coff_import_library:
   case sys::fs::file_magic::pecoff_executable:
     return errorOrToExpected(createCOFFObjectFile(Object));
   }
   llvm_unreachable("Unexpected Object File Type");
 }
 
 Expected<OwningBinary<ObjectFile>>
-ObjectFile::createObjectFile(StringRef ObjectPath) {
+ObjectFile::createObjectFile(StringRef ObjectPath, bool IgnoreValueErrs) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFile(ObjectPath);
   if (std::error_code EC = FileOrErr.getError())
     return errorCodeToError(EC);
   std::unique_ptr<MemoryBuffer> Buffer = std::move(FileOrErr.get());
 
   Expected<std::unique_ptr<ObjectFile>> ObjOrErr =
-      createObjectFile(Buffer->getMemBufferRef());
+      createObjectFile(Buffer->getMemBufferRef(), IgnoreValueErrs);
   if (Error Err = ObjOrErr.takeError())
     return std::move(Err);
   std::unique_ptr<ObjectFile> Obj = std::move(ObjOrErr.get());
 
   return OwningBinary<ObjectFile>(std::move(Obj), std::move(Buffer));
 }

lib/Object/SymbolicFile.cpp

 using namespace object;
 
 SymbolicFile::SymbolicFile(unsigned int Type, MemoryBufferRef Source)
     : Binary(Type, Source) {}
 
 SymbolicFile::~SymbolicFile() {}
 
 Expected<std::unique_ptr<SymbolicFile>> SymbolicFile::createSymbolicFile(
-    MemoryBufferRef Object, sys::fs::file_magic Type, LLVMContext *Context) {
+    MemoryBufferRef Object, sys::fs::file_magic Type, LLVMContext *Context,
+    bool IgnoreValueErrs) {
   StringRef Data = Object.getBuffer();
   if (Type == sys::fs::file_magic::unknown)
     Type = sys::fs::identify_magic(Data);
 
   switch (Type) {
   case sys::fs::file_magic::bitcode:
     if (Context)
       return IRObjectFile::create(Object, *Context);
Expected<std::unique_ptr<SymbolicFile>> SymbolicFile::createSymbolicFile(
   case sys::fs::file_magic::macho_preload_executable:
   case sys::fs::file_magic::macho_dynamically_linked_shared_lib:
   case sys::fs::file_magic::macho_dynamic_linker:
   case sys::fs::file_magic::macho_bundle:
   case sys::fs::file_magic::macho_dynamically_linked_shared_lib_stub:
   case sys::fs::file_magic::macho_dsym_companion:
   case sys::fs::file_magic::macho_kext_bundle:
   case sys::fs::file_magic::pecoff_executable:
-    return ObjectFile::createObjectFile(Object, Type);
+    return ObjectFile::createObjectFile(Object, Type, IgnoreValueErrs);
   case sys::fs::file_magic::coff_import_library:
     return std::unique_ptr<SymbolicFile>(new COFFImportFile(Object));
   case sys::fs::file_magic::elf_relocatable:
   case sys::fs::file_magic::macho_object:
   case sys::fs::file_magic::coff_object: {
     Expected<std::unique_ptr<ObjectFile>> Obj =
-        ObjectFile::createObjectFile(Object, Type);
+        ObjectFile::createObjectFile(Object, Type, IgnoreValueErrs);
     if (!Obj || !Context)
       return std::move(Obj);
 
     ErrorOr<MemoryBufferRef> BCData =
         IRObjectFile::findBitcodeInObject(*Obj->get());
     if (!BCData)
       return std::move(Obj);
 
     return IRObjectFile::create(
         MemoryBufferRef(BCData->getBuffer(), Object.getBufferIdentifier()),
         *Context);
   }
   }
   llvm_unreachable("Unexpected Binary File Type");
 }

test/Object/macho-unknown-lc-id.test

+#RUN: not llvm-objdump -private-headers %p/Inputs/macho-unknown-lc-id -macho 2>&1 | FileCheck %s
+#CHECK: unknown value found in object (unknown load command 0 for cmd value of: 3735928559)

tools/obj2yaml/obj2yaml.cpp

if (Obj.isCOFF())
     return coff2yaml(outs(), cast<COFFObjectFile>(Obj));
   if (Obj.isELF())
     return elf2yaml(outs(), Obj);
 
   return obj2yaml_error::unsupported_obj_file_format;
 }
 
 static std::error_code dumpInput(StringRef File) {
-  Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(File);
+  Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(File, true);
   if (!BinaryOrErr)
     return errorToErrorCode(BinaryOrErr.takeError());
 
   Binary &Binary = *BinaryOrErr.get().getBinary();
   // Universal MachO is not a subclass of ObjectFile, so it needs to be handled
   // here with the other binary types.
   if (Binary.isMachO() || Binary.isMachOUniversalBinary())
     return macho2yaml(outs(), Binary);